We can each build anything. So why can't we build together?
Every room I walked into at AI Bar Camp Berlin was stuck on the same problem. The stacks, the industries and the session titles were all different, but one question sat underneath them: we can each build anything now, so why can’t we build together?
That was the title of my talk. I brought it as a question because I couldn’t answer it. Nobody else could either.
The capability ladder
I opened with a five-level capability ladder from Nate B. Jones. It runs from ‘AI completes tasks’ at L1 to ‘AI agents run autonomously’ at L5. The transition that matters most is L3 to L4, from tool to system, more than the last step to L5. It is a systems problem, not a tooling problem.
My own projects sit on the lower rungs. At L2 is invoice automation: I drop a PDF in a folder, and it lands in the right row of a tax spreadsheet. It worked cleanly, because the problem was narrow, the output clear and the result easy to verify. I sit squarely at L3 with a campaign analysis pipeline that runs 181 ad campaigns headless every night, with automated QA gates. Claude Code is my interface there, and most of my personal projects live in this zone.
The step from L3 to L4 is the one I am working out now. The tooling for it is available, and the gap lies in the quality of my specifications and in knowing when to trust the loop.
The solo builder trap
Solo, I move very fast, and that speed has a price: the context lives in my head, spread across fifty agent sessions, and nowhere else. When I bring in a second person, we move backwards for a week while I try to hand over context that was never written down, because the agent and I worked it out together. I suspect many people in that room hit the same wall.
Three things that used to be inconvenient are now broken. Context is unshared: nobody else knows why the code does what it does, and the agent that knew is gone. Review is broken, because a PR where the agent wrote 80% of the code is the output of a conversation the reviewer wasn’t in. Velocity doesn’t transfer either: the second person joins, we are back to meetings, and it turns out the speed was personal rather than structural.
The L4 mirage
While preparing this talk, I consulted with the Faust AI team and saw a system built at L4: agents in production, a memory layer and self-optimising prompts. It was impressive work. Looking closely, I found a pattern that worried me. Only one engineer understood the full system, and there was no closed feedback loop with humans outside that engineer. Remove that person and everything stops, because the engineer IS the harness.
That isn’t L4. It’s a more fragile version of L3 with better aesthetics. Real L4 has to be legible to someone other than its author, and that is the part nobody has solved.
The same problem, in every room
My session was in the morning, and I spent the rest of the day walking into other rooms. The challenge kept surfacing in a different industry, on a different stack, under a different session title. Strip those differences away and every session circled the same two questions: where does shared truth live, and who keeps it true?
Five sessions, one question
Jan-Peter Kalus from Helion ran a session titled “I’m Not a Developer with an AI Tool — I’m a PM with an AI Developer”. His point was that the PM’s job is now to be the structured, reproducible interface between human intent and the AI building it. The role hasn’t disappeared; it has shifted entirely toward specification and ownership.
Markus Andrezak from überproduct put it more directly: lots of AI is still about individual contributions, “my newly developed skill”, “my chief of staff”. He asked how sharing skills and context works across departments, and he didn’t have a clean answer either. Jakub Mierzewski from Atlassian gave a lightning talk on the question I had opened with: how do agents and people teams collaborate, and what are the top challenges? It was a different audience asking the same question.
Tim Schikora from Aklamio went after the infrastructure layer and asked how an organisation should handle context, skills and project files. Git isn’t accessible enough, and GDrive isn’t structured enough for review, so he asked whether the answer needs a custom Markdown editor that sits between the two. Dirk Bartels from Bain asked the strategic version: Agentic AI in SDLC — should we build more, or should we build better? AI tooling adoption is widespread while the results lag, and his question was whether we are reaching for the wrong lever.
Where shared truth lives
Every one of those sessions came down to shared context, shared knowledge and shared data. Some people think the answer is git-based, with every piece of context in version-controlled files that agents and humans read from the same place. Others believe in vertical context managers: humans, often PMs, who own the canonical understanding of a domain and promote it as best practice.
One framing kept coming up: product managers are becoming context managers. Their job grows from defining what to build to maintaining the shared truth that agents can act on. The open choice is whether that truth is a single evolving document (Karpathy-style) or a constellation of files in disparate places that together constitute reality. Nobody had a clean answer.
What felt settled
A few things did feel settled across the rooms. Claude is the dominant tool, and the echo was loud and unprompted. We are re-inventing SDLC patterns for agents, such as kanban boards, tech lead roles and design reviews, because the old patterns still make sense even though the actors have changed. Prompt-engineering-based team setups feel like 2024 thinking, and the direction is toward agents operating within proper engineering systems, where instructions no longer masquerade as architecture.
What’s still unsolved
I asked the room directly whether anyone had cracked the onboarding problem, the context-sharing problem or code review at L4. Nobody had. A few people had partial approaches, and most had workarounds. These are the questions I am still sitting with:
- How do you review code when the agent wrote most of it and the conversation that generated it is gone?
- How do you onboard a new engineer into an AI-native codebase where half the architectural decisions exist only in agent context?
- How do you maintain ownership when agents can touch anything?
If you have something working, I want to hear about it.
The slides
The live slides from my talk are at waldo.vanderlore.de/talks/aicamp-2026/. The deck is interactive, and it is the version I presented.
One thing did get settled that day. The bottleneck is the rate at which humans make good decisions, more than code generation or infrastructure, and that showed up in every room, under every session title. Next year I’m coming back with one thing solved: a system where the decisions, and not just the code, are legible to someone who isn’t me.