Building and Sharing: How We Learn
Learning Is Building
At The Multiverse School, you learn by building things and sharing them with the community.
Not by completing assignments. Not by getting grades. By creating and sharing.
Why Building?
The Problem With Traditional Education
Banking model (Paulo Freire):
- Teacher deposits knowledge into passive students
- Students memorize and regurgitate
- Learning is abstract, disconnected from practice
- No real understanding
Problem-posing model (us):
- We investigate reality together
- Students actively build, experiment, discover
- Learning is concrete, connected to doing
- Deep understanding
You can’t learn to code by watching. You have to build.
See: How Multiverse Works for full explanation of pedagogy
What Counts as Building?
It’s Not Just “Apps”
Building includes:
Code projects:
- Small experiments
- Full applications
- Scripts that solve problems
- Tools for yourself or others
- Contributions to open source
- Proof of concepts
Writing:
- Blog posts explaining concepts
- Documentation
- Tutorials
- Reflections on learning
- Technical writing
Teaching:
- Explaining concepts to others
- Making videos
- Creating exercises
- Running study groups
- Answering questions (teaching is learning)
Exploration:
- Breaking things and documenting what happened
- Trying approaches and sharing results
- Failed experiments (these teach!)
- “Here’s what I tried and what I learned”
Creative projects:
- Art made with code
- Games
- Music
- Generative art
- Anything that uses what you’re learning
The unifying thread: You made something. You learned by doing.
The Learning Process
1. Start With Curiosity
Learning starts with questions:
- “How does this work?”
- “Can I build [thing]?”
- “What happens if I try [approach]?”
- “Why does this break?”
Not: “What’s the right answer?” (Banking model)
But: “What can I discover?” (Problem-posing)
2. Try Something
Build a tiny version:
- Start small
- It doesn’t have to work
- It doesn’t have to be good
- Just start
Example:
- Not: “Build a social media app”
- Instead: “Make a form that saves one piece of data”
- Then build from there
3. Break It (And Learn Why)
Things will break. This is good.
When it breaks:
- Read the error message
- Google the error
- Try to understand what’s happening
- Make a hypothesis
- Test it
Breaking things teaches you how they work.
4. Share What You Learned
This is where the learning solidifies.
Share in chat:
- “Here’s what I built”
- “Here’s what broke and what I learned”
- “Here’s a weird thing I discovered”
- Link to repo, blog post, video
Why sharing matters:
- Teaching consolidates learning
- Others learn from your journey
- You get feedback
- You build your public learning record
- Recognition comes from contribution
Learning Out Loud
Show Your Work
Share:
- Works in progress (not just finished things)
- Failures (what you learned from them)
- Confusions (others might have same question)
- Breakthroughs (celebrate!)
- Resources that helped you
Example share:
“I spent 2 hours debugging this. Turns out I had a typo in line 47. But in the process I learned how [concept] works. Here’s what I figured out: [explanation].”
This is valuable. You taught yourself AND taught others.
“I Don’t Know Enough to Share”
Wrong.
Beginners teaching beginners is powerful:
- You remember what was confusing
- You explain in accessible language
- Your struggles help others feel less alone
- You learn by teaching
You don’t have to be expert to share what you’re learning.
Building Together
Collaboration
You can build:
- Solo (then share)
- Pair programming (two people, one problem)
- Small groups
- Open source contributions
Collaboration teaches:
- Communication
- Working with others’ code
- Git workflows
- Code review
- Compromise
It’s okay to build alone too. Not everyone thrives in collaboration.
Body Doubling
Body doubling:
- Working alongside others (even silently)
- Shared focus
- Accountability
- Presence
How:
- Video call where everyone works on their own thing
- In-person coworking
- Discord/chat where people are working
It’s mutual aid through presence.
See: Mutual Aid in Action
Getting Recognition
How Recognition Works Here
No grades. No certificates (yet). Recognition comes from community.
You get recognition by:
- Sharing what you build in chat
- Helping others
- Contributing to discussions
- Teaching
- Being present
What this looks like:
- People respond to your work
- People ask you questions
- Facilitators highlight your contributions
- You build reputation
- Portfolio grows
This is how real-world tech works. Your work speaks.
Building Your Portfolio
Everything you share:
- Goes in your portfolio
- Shows your learning journey
- Demonstrates skills
- Tells your story
Portfolio includes:
- Projects (GitHub repos)
- Blog posts
- Contributions to open source
- Answers you’ve given
- Things you’ve taught
Employers care more about what you’ve built than where you went to school.
The Role of Exercises
Exercises Are Invitations
Exercises are:
- ✅ Starting points
- ✅ Invitations to explore
- ✅ Optional
- ✅ Scaffolding if you need it
Exercises aren’t:
- ❌ Required assignments
- ❌ Graded work
- ❌ The only way to learn
- ❌ More important than your own projects
Using Exercises
You can:
- Do the exercise as written
- Modify it to match your interests
- Use it as inspiration for your own project
- Skip it entirely
- Come back to it later
The learning is in the doing, not in compliance.
See: How Multiverse Works - What Exercises Are
When You’re Stuck
Stuck Is Part of Learning
Confusion is the first step of learning. If you already understood, you wouldn’t be learning.
When you’re stuck:
- Try something - Anything, to generate data
- Read the error - Error messages tell you things
- Google it - Someone else has hit this
- Ask in chat - Share what you’ve tried
- Take a break - Sometimes you need space
- Try again
Asking for Help
Make it easy to help you:
- Share what you’re trying to do
- Share the specific problem
- Share what you’ve tried
- Share relevant code
See: Mutual Aid in Action - Asking for Code Help
Building at Your Own Pace
Your Timeline Is Yours
There’s no:
- Deadline
- Required pace
- “Behind”
- “Ahead”
There’s only:
- Where you are
- What you’re building
- What you’re learning
Compare yourself to past you, not to others.
Taking Breaks
You can:
- Take breaks
- Step away
- Come back
- Go slow
- Go fast
Learning is not linear. Life happens.
What “Finished” Means
Nothing Is Ever Finished
In software:
- Projects evolve
- Version 1 is never perfect
- You’ll always see ways to improve
This is normal.
Ship it anyway. Done is better than perfect.
Share Before It’s Perfect
You can share:
- Messy code
- Half-working projects
- Things with bugs
- Works in progress
Perfection blocks learning. Sharing enables it.
Learning Styles
Different Approaches Work for Different People
Some people learn by:
- Building immediately (trial and error)
- Reading documentation first
- Watching videos
- Following tutorials
- Breaking things
- Teaching others
- Talking through problems
All of these are valid.
Find what works for you. Mix and match.
Neurodivergent Learners
If you’re neurodivergent:
- Your learning style is valid
- You might need different strategies
- Accommodations are available
- Build systems that work for YOUR brain
The Multiverse AI Toolkit
Free resource for all students: start.me/p/RMPGL5/multiverse-ai-toolkit
Includes:
- AI learning tools
- Job search resources
- Task breakdown tools (great for ADHD executive dysfunction)
- Organization help
- And more
AI can help with:
- Breaking down overwhelming projects
- Debugging
- Explaining concepts
- Generating ideas
- Learning new things
Use it as a tool, not a crutch. Build understanding, not just copy code.
Remember
Learning is building.
Share what you build (even if it’s messy).
Your timeline is yours.
Recognition comes from contribution, not compliance.
You learn by doing, not by being told.
Build. Share. Learn. Repeat.
See Also:
- How Multiverse Works - Full pedagogy explanation
- When You’re Struggling - When it’s hard
- Mutual Aid in Action - Asking for and offering help
- Neurodivergent Resources - Tools and strategies