Hello World: Why We're Building GUTT
I'm a CEO. I'm not a developer. Last week, I shipped code to production. Here's why that matters.
When you're three people in a room, everyone knows everything.
Every decision, every dead-end, every "we tried that in October and here's why it didn't work"—it's all there, distributed across three brains that sync up over coffee and Slack. Context flows naturally. Decisions are fast. New ideas build on old failures.
Then you grow.
At 30 people, context lives in scattered Slack threads. At 300, decisions are buried in meeting notes nobody reads. At 3,000, teams repeat the same mistakes because the people who made them left two years ago.
Organizations lose their memory as they scale.
This is the problem we're solving at GUTT.
The "Why" Behind GUTT
I've lived this problem at the most extreme scale imaginable.
I once scaled a team from 20 people to 2,000 in six weeks.
Not six months. Not six quarters. Six weeks.
I watched context fracture in real-time. Decisions that used to take an hour started taking days. Knowledge that lived in three people's heads suddenly needed to reach 2,000. The things that made us fast at 20—everyone knowing everything—became impossible at 2,000.
We hired brilliant people. We had good processes. We documented like crazy.
It didn't matter. The context loss was faster than any documentation could keep up with.
Your senior engineer knows why you chose that architecture. Your new hire (one of 1,980 new hires) doesn't. Your AI coding tool? It never knew in the first place.
So you get:
- Repeated mistakes from things tried and failed weeks ago (not even months—weeks)
- New hires who take forever to become productive because there are too many new hires to onboard properly
- AI agents that write brilliant code that violates your unwritten conventions
- Teams that should scale exponentially but barely scale linearly
The traditional solution is documentation. But at that speed, documentation is a joke. By the time you write it, it's outdated. By the time someone reads it, the team has moved on.
I've spent years since then thinking about this problem. Not theoretically—viscerally. I felt it. I lived it. I watched brilliant teams slow down not because people got dumber, but because context fractured.
What We're Building
GUTT captures organizational memory automatically—from your meetings, code reviews, Slack threads, Jira tickets. Not as static documents, but as a living knowledge graph:
- Why decisions were made, not just what was decided
- What was tried before and why it failed
- Connections between code, requirements, and discussions
- Patterns that worked (and didn't)
When someone—human or AI—needs context, they get it. Without changing how you work. Without asking you to maintain documentation you'll never update.
The result: Junior developers perform like seniors. AI agents build on your institutional knowledge instead of starting from scratch. Your CEO can contribute code.
Wait, what?
An Unexpected Proof Point
Here's something I didn't expect: I'm now a contributor to our codebase.
I'm not a developer. I haven't written production code in years. I can't whiteboard algorithms.
But last week, with Claude Code and GUTT's organizational memory, I shipped real features to production. Not toy examples. Actual PRs that made it through code review.
How?
Claude Code gives me the execution capability. GUTT gives me the context—our conventions, our architectural decisions, what we've tried before. I have access to the institutional knowledge that used to live only in senior developers' heads.
This isn't about me being special. It's about the context layer being that good.
If organizational memory can turn a CEO into a contributor, imagine what it does for:
- Junior developers who need to ramp up fast
- AI agents that need to understand your codebase conventions
- Remote teams where context doesn't transfer organically
- Enterprises where knowledge is trapped in silos
Who This Is For
We're building for teams where context is competitive advantage:
Development teams using AI agents — who want AI that learns from your patterns instead of starting from zero every time
Fast-growing organizations — where "just ask Sarah" stopped working six months ago, and you need a replacement that scales
Non-technical leaders — who want to understand (or contribute to) their codebase without constant handholding
Enterprises drowning in silos — where your seniors become juniors the moment they step outside their department
Anyone who's ever said "I wish we'd documented why we made that decision"
If institutional knowledge is valuable to you, but you don't have time to write it down—this is for you.
What We're Not Building
This isn't Confluence. This isn't Notion. This isn't another place for documentation to go stale.
This isn't search. "Find me the document about X" is solved. "Why did we make this decision three months ago?" is not.
This isn't just RAG. Retrieving chunks of text isn't the same as understanding why something happened, what it connects to, and what failed before.
We're building organizational memory—a system that captures context as you work and surfaces it when you need it, without requiring you to change how you work.
Learn more about how our platform works and the technology behind it.
Where We Are Today
We've been dogfooding GUTT since November 2025. Building GUTT with GUTT.
Some early signals that make us optimistic:
- Our development velocity increased while our team got smaller
- Cycle times dropped from weeks to hours
- A non-technical CEO (me) can contribute code
- AI agents write code that follows our conventions without being told
We're still early. We're figuring things out as we go. But the core thesis is proving out: when AI has access to organizational memory, everything changes.
The Vision
Today, organizations choose between staying small (so everyone has context) or scaling up (and watching context fracture).
Tomorrow, with organizational memory, you get both: the agility of a startup with the scale of an enterprise.
Junior developers ramp in days, not months. They have access to the same context as your ten-year veterans.
AI agents compound knowledge instead of starting from scratch. Every task builds on everything that came before.
Your CEO can contribute code. Or at least make informed technical decisions without asking "why did we build it this way?" every five minutes.
Teams scale exponentially, not linearly. Because knowledge accumulates instead of dissipates.
That's the future we're building toward.
Join Us Early
This is our first public post. We're building in public, sharing what we learn, and looking for teams who feel this pain.
We're looking for 5 design partners this quarter—engineering teams who want to shape what organizational memory becomes. Teams who are willing to experiment, give feedback, and help us figure out what matters most.
If you've ever lost momentum when someone left. If you've watched new hires struggle for months to get up to speed. If your AI coding tools keep making the same mistakes. If you're tired of context living in people's heads.
Book a 1-hour intro call
Or reach me directly: bart@mygutt.com
Bart Van Spitaels is the founder of GUTT. Previously scaled a team from 20 to 2,000 people in six weeks—and felt the pain of context loss firsthand. Now building organizational memory so teams can scale without breaking.
This post was written with Claude Code, assisted by GUTT's organizational memory. Yes, we use our own product. The irony is very much intentional.