The Map Is Discovered, Not Drawn

Watch this first: Discovery Quest is a looping, arcade-style visualiser of the method described below. The goal is in sight and the route is hidden in fog. Watch what happens when an assumption breaks. The scenario is illustrative, not a transcript of a real session.

Most diagrams of how software gets built show a straight line: requirements, design, tasks, delivery. It is a tidy picture, and it is not how complex systems are actually built.

After years of designing and delivering systems, I have settled on an approach that treats the route to a solution as something to be discovered, not assumed. Large language models have made that approach far more powerful. This article explains how I work, why I work that way even in domains I know well, and what it means for the quality of what I deliver.

Starting point: a clear outcome and an honest hunch

Every engagement begins with an outcome I can describe precisely. What I do not pretend to have, at that stage, is a complete route to it. I have experience, instinct and a working hypothesis. I do not have a plan I would trust, because the information needed to write one does not exist yet.

That is true of almost every non-trivial system. The honest question at the start is not "what are the tasks?" It is "what do we not yet know that will shape the design?"

Checkpoints are found, not scheduled

Consider a cost-reporting dashboard. The outcome is easy to state: a weekly view of what a fleet of agents costs to run. The route involves several distinct checkpoints. Integrate with the data source through its API. Tag the records so costs can be attributed. Build the interface.

In hindsight each checkpoint is obvious. In practice they surfaced one at a time, through structured dialogue with an LLM. I would state the outcome and my working hypothesis, and the model would put forward something I had not yet considered: attribute each record by agent, or define a formal data contract between the collector and the interface. Each suggestion revealed a checkpoint that had always been on the route but was not yet visible.

This is the center of my method. The checkpoints exist before anyone finds them. The discipline is in finding them early, and finding them cheaply.

Where specifications fit

I am a firm believer in specifications. A well-formed spec, covering requirements, design and tasks, is deterministic: the work is planned and then executed, and execution is predictable. That predictability is its value.

But a spec encodes what was known when it was written. It is best effort, and its quality depends on how well the problem could be described at the time. I therefore treat a spec as an island of certainty inside a sea of discovery. Inside the island, the path is straight. Outside it, the work is to find out where the next island should be, and to be ready to revise one if the conversation proves it wrong.

I write a spec when the unknowns in a region have been resolved. Writing one earlier than that produces confident documents that are expensive to unwind.

Ladders, snakes and dead ends

Progress through unexplored territory is not a steady climb. I find it useful to think of it as snakes and ladders, with the meanings adapted for engineering.

A ladder is a discovery that shortens the route. On the dashboard, the LLM suggested landing the data in object storage and letting the interface read it directly, which removed the need for a custom API. A whole stretch of planned work disappeared.

A snake is a discovery that invalidates earlier work. In the same project, a review of the attribution approach showed that costs are shared between agents, so a single tag per record could not be correct. Part of the spec was now void, and the work moved back to an earlier checkpoint.

A snake is not a failure. It is the cost of learning something that could not have been known earlier, and it is far cheaper to pay in a design conversation than in production. Every regression of this kind is documented, because the lesson learned is the real output of the detour.

The third kind of movement is the dead end. Real-time streaming was proposed and ruled out as disproportionate for a weekly view. That idea stays on the map as a closed branch. It cost time to explore, and it protects the project from reopening the question later.

Experience does not remove the need for discovery

It would be natural to assume that this approach is for unfamiliar territory, and that a specialist should simply plan and build. That is not how I work.

When I am building in a domain I know well, I follow the same cycle: state the outcome, share my hypothesis, and test it in dialogue with the LLM before committing to a route.

The reason is that expertise has a boundary, and that boundary cannot be seen from the inside. My experience is what I have built, read and been taught. A large language model has been exposed to an enormous range of architectures, code bases and design patterns, far beyond what any one engineer will see in a career. In conversation, that breadth is available on demand. I think of it as working with a mentor who has seen how thousands of teams approached a problem like mine, and who is always available to discuss it.

If I skip that step because I believe I already know the answer, the result is limited by my own experience. If I take it, one of two things happens. Either the model confirms my approach, which is valuable because the approach has now been tested. Or it surfaces an option I would not have reached alone, which is where the largest gains come from.

Experience changes the quality of the conversation, not whether it is needed. It lets me ask sharper questions, recognize a good suggestion sooner, and reject a weak one faster. That is where years of engineering judgment earn their keep.

It also defines the working relationship. The mentor advises, and I decide. Models can be wrong, overconfident or out of date, so every suggestion is tested against my own judgment and against the realities of the system. The method works because two different kinds of knowledge are checked against each other.

Two voices, one map

Neither party could draw the map alone. My direction and domain judgment provide the heading. The LLM provides concepts, patterns and alternatives. The most valuable checkpoints tend to be those where the two meet.

The fog is not a measure of how little a person knows. It is the part of the route that nobody has yet examined, however experienced they are. A more experienced engineer clears that fog faster and with better judgment, but the starting condition is the same: an outcome in sight and a route that has not yet been seen.

Reading the visualiser

Discovery Quest is a single web page built with three.js, styled after 1980s arcade vector displays. Here is what you are seeing in it.

  • Fog. A grid of dark tiles covers the map. The target glows on the far side, but the route is hidden.
  • Hunches. A new checkpoint first appears as a flickering box marked with question marks. Once the dialogue names it, it settles and the fog around it clears.
  • Colors. Amber marks my hunch, cyan marks an LLM suggestion, and violet marks both.
  • Specs. When a specification is written, a white boundary forms around a group of checkpoints and the wobbly paths inside snap straight.
  • Ladders and snakes. A ladder is a bright arc that carries the token forward. A snake is a magenta curve that pulls it back, marks the spec as invalidated, and sends the paths inside it wobbly again.
  • The plan. A dashed line runs straight from start to finish: the route that was expected. Beside it is the route actually walked.

By the end, the retained work turns green and the fog lifts. The gap between the dashed line and the walked path is the point of the whole piece.

What this means for the people I work with

  1. Early discovery of what would otherwise surface late. Unknowns are explored through dialogue at the point where changing course is cheap.
  2. Specifications written when they can be trusted. Fewer documents, and fewer that need to be unwound.
  3. Designs informed by a far wider body of practice than one engineer's experience. Experience sets the direction. The model broadens the options.
  4. Transparent decisions. Dead ends, regressions and the reasons for them are recorded, so the rationale behind the final design is traceable.
  5. Human accountability. The model advises and the engineer decides. Suggestions are verified before they shape the system.

Closing

The straight line is the story we tell once a project is complete. While it is being built, the route is hidden, and the honest description of good engineering is a disciplined series of discoveries: some carry the work forward and some send it back, and all of them improve the final result.

That holds whether the territory is new or well known. The best outcomes come from combining deep experience with a mentor that has seen more routes than any one engineer, and being willing to let it show me one I had not considered.

The map is discovered, not drawn.