Designing, not just coding/
Now that tools write code, anyone can build. Design is still a craft
A code-writing tool can produce a function in a few seconds. Many people conclude it can build an entire piece of software.
That confuses two different crafts. Writing a line of code and designing a system that still stands in five years are not the same thing.
This article isn't against these tools. We use them ourselves, every day, in-house. The question isn't whether to do without them. It's what they really replace, and what they don't.

What tools that write code have really changed in software development
Tools that generate code have made writing it accessible to almost everyone. Someone with no technical training can now get a script, a page or an automation just by describing what they want.
It's a real change, and a useful one. Tasks that took hours get done in minutes. Ideas that stayed on paper become prototypes in an evening.
At Lunnar, this kind of tool is part of the daily routine. It helps us build faster once we know what to build, exactly the way a machine assists a carpenter without deciding for them what to make.
But producing code has never been the hard part of a software project. The hard part is knowing which code to write, in what order, within what limits, and why.
These tools answer "how do I do this" very well. They don't answer "should this be done, and done this way".
The confusion isn't new. It already existed with no-code, which made assembling tools accessible to everyone without doing the same for the thinking behind them. Code generators simply amplify it, on a different scale.
The architect analogy: building is not designing
An architect doesn't lay bricks. An architect draws a plan that decides where each brick goes, what the building will have to carry, and how it will age. A tool that generates code does roughly what unlimited access to materials and workers would do: it executes fast, but it doesn't think through the structure.
Having all the materials in the world doesn't tell you where to pour the foundations. It doesn't tell you what the building will have to bear in five years either, when you have three times as many users, twice as much data, and regulations that have changed.
An architect with unlimited materials would go faster. They wouldn't draw any fewer plans. If anything, the opposite: the faster the construction, the more solid the plan has to be before starting, or you just go fast in the wrong direction.
The plan before the foundations
Before the first line of code, decisions have to be made: how the data is structured, what has to stay separate, what has to talk to what, and what must be protected first.
These decisions aren't visible right away. They only show later, as the system grows and every early choice weighs on everything built on top of it.
A well-thought-out plan isn't written in one sentence typed into a code generator. It's drawn by understanding a business, its real pain points, and what it will become over the next few years.
What breaks when nobody drew the plans
Three things break, almost always in this order.
Technical debt. Code that works today, but that nobody can change without breaking everything around it, because it was never designed to move.
Security. Holes that don't show in normal use, but open up as soon as someone tries to exploit them. They can't be bolted on afterward. They have to be built into the structure.
Inconsistent data. The same piece of information stored in two different places, which ends up contradicting itself. A prospect with two phone numbers, an appointment with two statuses. Nobody knows anymore which one is right.
These three problems almost never appear on day one. They appear six months or two years later, once they've become expensive to fix.
The faster the tool was built, the sooner these problems arrive. That's no coincidence: a fast build and a sound plan are two different things, and one doesn't make up for the other.
3 signs a project was coded without being designed
These signs often show up together, on tools built fast with no design step beforehand.
Nobody can explain why a feature was built the way it was. The code works, but the logic behind it has been lost. Every change becomes a gamble.
Every new request takes longer than the last. The system wasn't designed to evolve, so every addition works around what already exists, a little harder each time.
The same bugs come back after being fixed. A sign that the problem was never addressed at the root, only covered up on the surface, because nobody took the time to understand the cause.
None of these three signs shows up in a demo. They reveal themselves with use, often after the tool has already become central to the company's daily work. That's what makes them expensive: you find them too late to fix them cheaply.
What a designer does
Designing means deciding on the structure before writing, with an eye on what the system will have to carry in several years, not just on what it has to do tomorrow.
It means understanding a business from the inside before proposing anything. Setting priorities, cutting what isn't needed, choosing what has to exist now and what can wait. Laying out the data structure, the security and the automations before anyone writes a line.
This work happens before the quote, not after. A quote built without this step commits to nothing solid: it prices a hunch, not a verified plan.
That's exactly what our method describes: a demo on your real work, then the Process Map and Plan step, before any building. Code-writing tools then help us build faster, but they come in after this work, never in its place.
The result of this work is a tool that exists only for you, whose data you keep unconditionally, and that was designed to last.
One last thing, to be clear: none of this is against these tools. Used after the design, once the plan is set, they speed up construction. Used instead of design, they quickly produce something that will struggle to age well.
To understand when an off-the-shelf tool reaches its limits and where custom design takes over, our article on the limits of no-code goes through the concrete thresholds.
If you have a project where this design step was skipped, or if you're starting from scratch, the simplest thing is to talk to us directly rather than guess on your own.
Frequently asked questions
Can a code-writing tool replace a developer?
It replaces part of the code writing, not the design. Deciding on a system's structure, anticipating what it will have to carry in five years, thinking through security and data consistency are still human work, even with these tools at hand.
What exactly is a software architect?
The person who draws the structure of a system before it's written: how the data is organized, what has to stay separate, what has to be protected, and what has to be able to evolve without breaking everything two years later.
Does Lunnar use code-writing tools to build its software?
Yes, in-house, to speed up construction once the plan is set. They don't decide the architecture or the priorities: that design work is still done by people, before the first line of code is written.
Why does technical debt build up even with generated code?
Because technical debt comes from a lack of structure, not a lack of writing speed. Code produced fast, with no plan behind it, piles up the same way as code written by hand in a rush.
Curious what it would look like for you?
Tell us how your agency works today, and we'll tell you honestly what a custom tool would change.
Talk about your business