Software as a Coloring Book

There are many metaphors for thinking about AI in the workplace. Here's one more. To get the most out of agentic coding, we should think of a software project like a coloring book: the human decides where the outlines go, and the LLM fills in the gaps with a crayon. Writing lines of code, like building a powerpoint or a spreadsheet, is more time consuming than it is difficult. If there is artistry in software design, it is not in filling the space between the lines, but in picking the right lines to begin with.

AI image generation illustrates this point. Using an online paint app, I drew a simple outline of a Christmas tree. Then, I used Gemini 3.5 Flash to generate a new image with the prompt "Create a Christmas tree, while respecting the outline of the tree that I have provided."

Not bad! The model interpreted the requirement for the outline much more literally than I expected, but it certainly produced a Christmas tree. Next, I repeated the same exercise, but with a new outline that suspiciously resembles a pumpkin. However, I kept the same prompt, declaring the outline a tree. As always, the model did the job without hesitation.

Oh no, this isn't what I wanted at all. The new image appears to contain the lower half of a Christmas tree. The pumpkin stem looks like the top of an ornament; there is a colorful star topper, but it is oddly embedded in the tree itself, hardly different from the ornaments surrounding it. I didn't ask for presents on the bottom, nor a living room in the background (though the wood molding looks nice). This is less a pumpkin-shaped tree, and more a pumpkin-shaped window into a Hallmark Christmas scene.

The bottom line is that I could not tell someone I have produced a Christmas tree without strained credulity or outright confusion. How we interpret this failure depends on how we feel about artificial intelligence itself. AI doubters might be quick to accuse the model of hallucinating details I didn't want, like the presents, or they may condemn LLMs altogether as always generating mistakes and poor output. AI zealots might say that the image is awesome, actually, and far exceeds any tree a human could decorate. For the rest of us who merely want to use these tools to the best of their ability, the fix is simple: I should have drawn a better outline.

Software production is no different. Instead of black outlines, we write data models, interfaces, invariants, and other sorts of explicit contracts. We declare the format a piece of code must accept, what format it must output, and rules for the transformations in between. Just as it knows what a Christmas tree looks like, the LLM knows TypeScript, and it will fill gaps between our specifications with code. When agentic coding fails, it is likely we fed it contradictory information, or we asked it to fill in too much blank space at once, or worst of all, we allowed it to draw the outlines for us.

Some engineers think of themselves as painters, that good software is only possible with flashes of inspiration. If we had to use AI to create software like it was a painting, we would be in trouble. Thankfully, software production is largely bureaucratic; the hardest part is not writing the code, but figuring out what the code needs to do. We cannot tokenmaxx our way to Matisse, but we can certainly let AI fill in a coloring book. To understand the future of knowledge work, this distinction, and the humility it requires, cannot be avoided.

If this sort of delegation sounds familiar, it is because it retraces the traditional relationship between a project lead and junior teammates — the lead writes out the shape of a project, and team members write the code. But what good are juniors if an AI can do the same work? When the business media (or your employer) vaguely talk about junior roles disappearing, they are addressing this tension, even if they never quite make it to concrete details. What is failing us are not juniors, but rather our stilted imagination of what they can and should be doing.

In the coloring book analogy, we considered only two actors, a human designer and a capable AI model. Now, we must include a third: a junior engineer. Instead of treating them as crayon-wielding colorers, we need to recast juniors as apprentice outliners. The team lead produces an outline, and the junior draws their own smaller, self-contained outlines afterwards. In software project terms: a lead lays out a new API design and the resources that it must process; instead of writing the authentication contracts themselves, the lead delegates this responsibility to the junior. Instead of writing code, the junior crafts specifications to cover the delegated requirements, and these specifications are finally implemented by the coding agent. The two human roles are fundamentally doing the same thing, only at different scales.

When done well, the result is a higher quality schematic, which gives the team tighter control over what the AI produces. I reran the Gemini exercise using a more detailed outline, with secondary, delegated work in grey. The output adheres to the new, detailed schematic just as easily as the original (though I still wouldn't put it in a museum).

As always, adding headcount to a project increases the overall complexity and heightens the risk of miscommunication. For example, what if a lead produces an outline that doesn't fit the situation, like a pumpkin-shaped tree? In an unhealthy team culture, the junior may not push back, and instead do their best with a flawed design; the team may end up with a pumpkin tree. On the other hand, the lead is now estranged from actual code generation; if the code begins to diverge from the original plan, they will only know as much as their teammates feel comfortable sharing. In this sense, AI has changed nothing about how successful teams conduct themselves.

In fact, the fate of a software project depends more on team culture than it ever did before AI. We need to invest in processes that connect teammates, reveal flaws early, and produce exceptional designs. Juniors are not just useful, but critical; we haven't begun to imagine what a team full of designers could create. Before they can graduate to high-skill outlining, leads must go even higher.