For decades, the codebase was a stable environment, home to developers, a few build scripts, and a test suite that everyone was afraid to touch. Then, almost overnight, a new species appeared. It works at remarkable speed. It never sleeps. And it has absolutely no memory of yesterday.
This is the coding agent.
A voracious forager
The coding agent is a forager. When given a task, it moves through the codebase looking for anything that might help. It reads files, searches folders, and gathers examples, then produces new code in minutes.
What it finds shapes what it builds. If the nearest example of a form uses a clickable <div> instead of a button, the agent will happily produce another clickable <div>. If the nearest card component hardcodes a color, so will the next one.
The agent isn’t being careless. It’s being an excellent mimic.
Mimicry
Mimicry is the coding agent’s greatest strength. It can match the style of the code around it so closely that reviewers can’t always tell who wrote what.
It’s also its greatest weakness. In a healthy codebase, it copies healthy patterns. In a codebase with fourteen buttons, it picks one at random and makes a fifteenth.
Observers have noted that an agent will often build a perfectly good component from scratch, three folders away from an identical component that already exists. It didn’t know to look there. Nobody told it.
A creature with no memory
Here’s the most extraordinary thing about the coding agent. Every morning, it wakes up having forgotten everything. The design system review from last week, the conversation about accessibility, the decision to stop using that date picker: gone.
Each session, it arrives in the codebase like a newcomer exploring an unfamiliar forest. It will rediscover the same paths, and sometimes the same mistakes, again and again.
Marking the habitat
But the agent responds remarkably well to clear signs. Experienced teams have learned to mark the territory. They leave instructions in files the agent reads at the start of every session, often named something like AGENTS.md. These files say which components to use, which patterns to avoid, and how to check the work.
Some teams go further, with lint rules that catch hardcoded colors and design audits that block a commit until the code uses the system’s tokens. The agent, encountering these, simply adjusts course and tries again. It never takes it personally.
In a well-marked habitat, the agent’s behavior changes dramatically. It reaches for the real Button component. It uses the system’s colors. It checks its own work against the rules, every time, without being reminded.
A new balance
Like any new arrival, the coding agent has unsettled its ecosystem. Developers now spend less time typing code and more time describing what good code looks like, reviewing what the agent produced, and tending the patterns it will copy.
It’s a different kind of work. The codebase is less of a forest to explore and more of a garden to keep. The healthiest gardens, observers agree, are the ones where the good examples are the easiest ones to find.
As evening falls, the agent finishes its final task of the day, opens a pull request, and forgets everything. Tomorrow, it will arrive again, eager and fast and entirely new.
This episode is part of the Wild Interfaces series.