where good ideas come from (for coding agents) • Solving the decision problem skip to content

Close

On this page<br>the idea-space metaphor (and what the seven ways add to it)<br>quick sidequest: the seven ways<br>the running example: “make webhook ingestion reliable” (totally plausible, not actually shipped)<br>day 1: I ask for “reliability.” the agent gives me plausible nonsense.<br>day 2: adjacent possible - I stop asking for outcomes and start asking for stairs.<br>day 3: liquid networks - I build a context packet so it stops inventing my codebase.<br>day 4: slow hunch - a real design question appears, and we don’t pretend it’s settled.<br>day 5: serendipity - I feed it anomalies instead of asking it to “be creative.”<br>day 6: error - we make the feedback loop the main character.<br>day 7: exaptation + platforms - we stop patching and extract primitives.<br>what changed across the week wasn’t the model. it was the user.<br>the practical punchline<br>epilogue: ok, but doesn’t this mostly work for seniors?<br>appendix: the context packet (a tight template)<br>template (copy/paste)<br>a filled example (webhook reliability)<br>where good ideas come from (for coding agents)<br>3 January 2026 (and the part where users have to level up)

I’ve been thinking about why some people absolutely cook with coding agents, and some people bounce off them hard. I had a thought last week: if llms are “next token predictors” in the small (i.e., sentence finishers) then in the large they’re closer to “thought completers.” you give them a few crumbs of context, they infer the genre, then they sprint down the most likely path in idea-space. which makes “good prompting” feel less like magic words and more like navigation: you’re steering the model toward a region of the space where the next steps are both plausible and useful. I wanted a better map for that, so i used steven johnson’s “where good ideas come from” as a rubric, the seven patterns that reliably produce interesting ideas, and tried applying it to coding agents: where they’re naturally strong, where they reliably drift, and what a user has to supply (constraints, context, oracles, loops) to make the whole thing converge.

tl;dr: a plausible “week in the life” you can map onto your own codebase. the point is to make the user-adaptation story concrete: agents are excellent at adjacent-possible work, but they only become reliably useful when you supply constraints, context, an oracle, and a loop .

the idea-space metaphor (and what the seven ways add to it)

it’s tempting to picture an llm as navigating a huge multidimensional “idea-space”: your prompt lights up certain internal features, which reshapes the probability landscape of what comes next, and generation is basically a trajectory through that landscape. in that framing, context engineering is just steering - adding constraints, examples, and relevant artifacts so the model’s “next steps” stay in the neighborhood you care about. johnson’s seven ways are useful here because they explain which kinds of trajectories llms find naturally, and which ones require help: models are natively strong at smooth, local moves like the adjacent possible (small diffs, incremental refinements) and at platforms (interfaces, scaffolds, reusable primitives), and they can do exaptation well when you explicitly state affordances and constraints. they’re weaker where progress depends on reality pushing back - error and serendipity - unless you give them feedback channels like tests, benchmarks, traces, and experiments that create a gradient toward truth. and they only approximate liquid networks and slow hunches when you supply diverse “voices” (prior art, docs, debates) and persist ideas long enough to recombine later. the point isn’t that llms can’t roam the space; it’s that they need mechanisms that select and validate the paths worth taking.

quick sidequest: the seven ways

steven johnson’s “where good ideas come from” is one of those lists that sounds like it belongs on a poster until you use it as a diagnostic tool. here’s the version that matters for engineering:

the adjacent possible - most “new” ideas are the next reachable step from what already exists. stairs, not teleportation.

liquid networks - ideas show up when partial thoughts collide: people, yes, but also artifacts (docs, code, past debates).

the slow hunch - many good ideas start half-baked. you keep them around until they meet the missing piece.

serendipity - luck plus recognition; you notice the useful anomaly when it appears.

error - failure is information; feedback turns wandering into convergence.

exaptation - repurpose a thing built for one job into a different job. reuse as invention.

platforms - stable primitives and standards let lots of people build lots of things faster and safer.

now: drop an llm coding agent into this picture. what changes?

my take: the seven patterns don’t go away. agents just amplify some of them and brutally expose where you’ve been relying on implicit human context for...