A few weeks ago, Anthropic published an article that caught our attention. A team of 16 Claude agents, working in parallel with no human intervention, wrote a C compiler from scratch. 100,000 lines of Rust code, capable of compiling the Linux kernel. Cost: $20,000 and two weeks.
It's the kind of project that would have required a team of senior engineers working for months. And an AI did it alone.
AI already writes code, and it's getting better at it. This is going to radically change our profession. But there's a nuance that often gets lost in the conversation — and that's what we want to talk about in this article.
Code is not product
A compiler is a technically impressive project. But it's also a very well-defined problem: there's a clear specification, objective tests, and an automatically verifiable result. AI performs best when the problem is closed and measurable.
In our day-to-day work, projects aren't like that. We build web platforms, applications, and management systems — products that need to solve real business problems, fit into existing workflows, and run reliably in production. Code is only part of it. The other part — often the most complex — is understanding what needs to be built, making the right architectural decisions, and ensuring everything works as it should.
That, as of today, is not something AI does on its own. And it's exactly where we've refocused our work.
How we used to work
Like most development teams: we received requirements, did a general design, and spent most of our time implementing. Writing code, solving problems on the fly, testing the most critical parts, delivering.
It worked. But if we had to put numbers on it, probably 70% of the time went into writing code and 30% into thinking, designing, and validating.
Agents working together
How we work now
That ratio has flipped.
We use Claude as our primary development tool. But we don't tell it "build me an application". We give it concrete specifications: what to build, how it needs to fit with the rest of the system, and what criteria it needs to meet.
In practice, our process looks like this:
Design and specification. Before writing a single line of code, we spend time precisely defining what we're building. Data structures, component relationships, edge cases, business rules. The clearer the specification, the better the result — with or without AI.
Assisted implementation. Claude writes code based on those specifications. It's fast and generally accurate, but it requires a trained eye to spot when it takes shortcuts, when it doesn't understand the context, or when it produces something that technically works but isn't maintainable.
Comprehensive testing. This has probably been the most significant change. We used to test only the most critical parts: payment validations, complex business logic, sensitive integrations. Now we test everything. AI has made writing tests much faster — we define what to test and which scenarios to cover, and the test implementation itself has become almost trivial. We've fully adopted TDD: tests first, then code.
The direct consequence is quality: if the AI introduces a bug when modifying something, the tests catch it. It's a safety net we didn't have this comprehensively before.
Review and validation. Everything goes through human review. We review the logic, the structure, the efficiency, and above all, that what's been built solves the client's real problem — not just the problem as the AI interpreted it.
Iteration. With this process, iterating is more agile. If something doesn't fit, we adjust the specification, regenerate, and validate again. The feedback cycle has shortened considerably.
What we've learned
AI is an excellent production tool: generating code, writing tests, refactoring, documenting. It's a real productivity multiplier.
But it has clear limitations. It doesn't understand the client's business. It doesn't know that a "delivery date" field has logistical implications affecting three departments. It won't question a requirement that doesn't make sense. It won't propose a simpler solution if you don't give it enough context.
Team experience matters more than ever. The difference between using AI with good judgment and without it is the difference between a solid product and technical debt accumulating at high speed.
Where this is heading
The developer's role has changed. We spend more time thinking, designing, specifying, and validating. Less on mechanical implementation. And the result is better: more test coverage, fewer bugs, more robust solutions.
AI will keep improving. What today requires a team that carefully thinks through specifications might tomorrow be done more autonomously. But our experience so far is clear: the combination of powerful tools and a team with the judgment to use them is what produces good results.
And that's what we offer our clients.
