3 years of working with AI on code, and the thing that changed most wasn't the models. It was the structure around them.
That took a while to notice.
Where it started
Early 2023. smol-developer showed what was possible: an LLM-driven CLI that turned a specification into a scaffolded project. The creator framed it as human-centric, a tool to augment rather than replace. That framing felt honest, and the concept was compelling enough to keep going despite the cost.
The cost was real. Write an instruction, trigger a build, review what came out, decide it was wrong, refine the instruction, repeat. Tokens weren't cheap then, the iteration loop was slow, and a significant portion of each session was spent reading and verifying output rather than producing it. But the direction felt right. Whether it was actually faster end-to-end depended heavily on how much you'd put into the specification upfront.
Specification driven development
The next phase had no agreed name. Let's just refer to it as specification driven development.
Before starting a task, write a specification: architecture decisions, expected behaviour, constraints. Paste it into the session. Once the task was done, the spec came out. The next task needed a different spec. You were continuously managing what the model could see, even if that's not how you'd have described it then.
The session-to-session context loss was the problem that never went away. Each session started from scratch. Decisions made last week weren't available unless you manually surfaced them. The model had no memory of what the project was, what had been tried, or what patterns the codebase had settled into. You compensated by writing longer specs. The specs got unwieldy.
It was working, roughly. Manual, inconsistent, didn't carry between projects.
Structure replaced intuition
The setup became deliberate. .claude directories. CLAUDE.md files documenting architecture, conventions, and gotchas. A /docs folder the model could be pointed at. The session became less about what you said in the prompt and more about what was already in place when it started.
A piece by Morph names this practice: context engineering. The model doesn't need better phrasing; it needs a better environment. A CLAUDE.md is a project constitution loaded into every session. Context loads in a defined sequence. One number from that piece: Claude Code uses 5.5x fewer tokens than Cursor for equivalent tasks. Not because it's smarter. Because it's more deliberate about what it reads.
"I thought I was getting better at prompting. I was learning to manage context."
Where it landed
The logical step was to stop rebuilding this structure per project. I put together engineering-ai-foundation: a spec and template system for applying this structure consistently across new and existing repos. Machine-readable schemas. A bootstrap workflow for upgrading existing projects.
It's not finished. The tools keep changing, the practices keep shifting, and whatever feels settled now will probably look rough in another year. The models got better. What actually changed was the work done before the prompt.