I like being able to turn an idea into a working application in a few hours with AI. It makes experiments possible that I wouldn’t have bothered with before.
I also understand the temptation that comes with it: if building the application was this easy, why spend much time on its architecture? We can always rebuild it.
For a prototype with no users and no important data, that’s often true.
What gets harder to replace
Take a small order management tool. At first, it’s a few forms and tables. Rewriting it would be straightforward.
Six months later, it holds customer records and orders, feeds the accounting system, and runs the warehouse’s daily workflow. Replacing the screens might still be easy. Replacing the tool now means moving those records, keeping the integrations working, and making sure orders don’t get lost along the way.
The cost of generating new code tells us very little about that work.
Before choosing a database or splitting the application into components, I’d want to understand what the business expects from it. Who relies on it? What would make it unsuitable, even if all its features worked?
An order management tool for a small shop and one coordinating several warehouses might look similar in a demo. But their requirements for availability, data consistency, and integration can lead to very different architectures.
Foundations before implementation
This is where I find the arc42 method useful.
It’s best known for its architecture documentation template, but the method is about the work behind those documents: clarifying requirements, designing structures and crosscutting concepts, communicating decisions, following the implementation, and evaluating the result.
Its starting point is particularly relevant here: clarify the most important quality requirements before making architectural choices.
“It needs to be reliable” doesn’t give us much to work with. “The warehouse must be able to prepare orders during an accounting-system outage” does. We can discuss that requirement with the people affected, design for it, and check whether the solution meets it.
For me, good foundations mean having a shared understanding of:
- The purpose and priorities. Whose problem are we solving, and which qualities matter most? A tool used once a month doesn’t necessarily need the same availability as one that keeps a warehouse running.
- The constraints and context. What must we work with? Existing systems, hosting restrictions, regulations, and team capacity all affect which solutions make sense. Drawing the system boundary also makes clear what we control and what we depend on.
- The structure and approach. How do the main responsibilities follow the business domain? How will they interact, and how will shared concerns such as persistence, security, and error handling work?
- The reasoning and uncertainties. Why did we choose this approach? What alternatives did we reject? Which assumptions still need testing?
These are not answers an AI should quietly invent while implementing the next feature. They need input from the people who know the business and will live with the result.
Enough guidance to build, not a plan for everything
I don’t read arc42 as a demand to finish a large document before writing code. The method is iterative, and it explicitly recommends keeping written documentation as small as the situation allows.
For a small application, a short description of the goals, a context diagram, a sketch of the main responsibilities, and a few recorded decisions may be enough to start.
I’m happy to replace an implementation. What I’d like to carry forward is a clear understanding of what the system must do, why it’s structured that way, and where its limits are. That’s a much better basis for the next version than another round of prompts starting from scratch.
How I work now
These days, I work solo, directing a flock of AI agents to code the applications I design. I’m the one thinking through the architecture, guiding the implementation, and reviewing what comes back.
That removes a lot of the gap between design and development. There’s no handoff to another team, no waiting for everyone’s schedules to line up, and less room for the reasoning behind a decision to get lost along the way. I can make a decision, put the agents to work, and check the result while the context is still fresh in my head.
Once the foundations are solid and clearly defined, the path from what’s in my head to working software is remarkably short. That’s what I enjoy most about this way of working: I can spend the time to think something through properly, then see it take shape almost immediately.
This is the first of four follow-up articles to Cheap to build does not mean disposable.
Valérian de Thézan de Gaussan