You know the feeling. You hand Cursor or Claude Code a task — something real, not a toy demo — and for the first thirty seconds, it’s magic. The agent reads your codebase, identifies the right files, starts making changes that actually make sense. You lean back. You think: this is it.
Then step four happens. The agent forgets which file it just edited. It rewrites a function it already rewrote. It breaks something it fixed two minutes ago. You watch it spiral — confidently, eloquently, like a brilliant surgeon who keeps forgetting which patient is on the table.
The model was never the problem. Your complete lack of structure was.
Every developer using AI coding tools has hit this wall. And the reflex is always the same: blame the model. Maybe Claude 3.5 isn’t smart enough. Maybe I need to try o1. Maybe I should tweak my prompt, add more context, adjust the temperature, sacrifice a goat to the API gods.
So you switch models. You rewrite your prompt. You paste in more context. And for a while — maybe a slightly longer while — it works. Then the same thing happens. The agent drifts. It loses the thread. It starts doing something adjacent to what you asked but fundamentally wrong.
Here’s what’s actually going on: the bottleneck isn’t intelligence. It’s state management.
Think about what happens when you work on a complex task. You don’t hold everything in your head. You write things down. You make a checklist. You track what’s done, what’s in progress, what’s blocked. You maintain context across interruptions — not through sheer memory, but through external structure.
AI agents don’t do this. They get a prompt, they execute, and then the context window fills up, and the earliest, most important instructions start to evaporate. The agent doesn’t know it’s forgotten something. It just keeps going, increasingly untethered from the original plan.
A genius with amnesia is less useful than a mediocre developer with a checklist.
This is the dirty secret of the AI coding agent space. Everyone’s obsessed with benchmarks — MMLU scores, HumanEval results, context window sizes. But the real leverage isn’t in the model. It’s in the invisible scaffolding: task queues, state tracking, context preservation. The boring infrastructure that nobody tweets about because it doesn’t sound like the future.
Backlog, a new open-source tool from security researcher Mazin Ahmed, attacks this problem head-on. It’s not another model wrapper or a fancy prompt template. It’s a lightweight framework that gives your AI agent something it desperately needs: a memory of what it’s supposed to be doing.
The concept is almost embarrassingly simple. Backlog maintains a structured task list — a backlog, in agile terminology — that the agent reads from and writes to as it works. Each task has context, status, and dependencies. When the agent picks up a task, it knows what came before it, what’s been done, and what still needs to happen. When it finishes, it updates the state. When it drifts, the backlog pulls it back.
It’s the difference between handing someone a vague instruction and walking away versus handing them a project board with tickets, descriptions, and acceptance criteria.
But here’s the paradox that should make you uncomfortable: we built autonomous agents to reduce human overhead, and now we’re discovering they need more structure than human developers do. We gave AI the freedom to think for itself, then realized it can’t remember what it was doing five minutes ago.
We designed agents for autonomy and then had to build cages to keep them useful.
This isn’t a failure of AI. It’s a reality check. Autonomy without scaffolding isn’t autonomy — it’s chaos with confidence. The most effective agentic workflows aren’t the ones where you fire off a prompt and pray. They’re the ones where you define the work, structure the context, and let the agent execute within guardrails that prevent drift.
If you’ve been using Cursor, Copilot, Claude Code, or any other AI coding tool and hitting the same wall — the agent starts strong, then unravels — stop blaming the model. Stop rewriting your prompt for the twentieth time. Look at your process. Are you giving the agent a task, or are you giving it a task structure?
The developers who get real leverage from AI coding agents aren’t the ones with the best prompts. They’re the ones who understand that the model is just the engine. The steering wheel — task breakdown, context management, state preservation — is where the actual control lives.
Backlog is one early attempt at building that steering wheel. It won’t be the last. But the insight behind it — that structured task management matters more than raw model capability — is the one that separates developers who use AI as a toy from those who use it as a tool.
The next leap in AI coding won’t come from a smarter model. It’ll come from better scaffolding that makes the models we already have actually usable.
FAQ
Q: Isn't this just adding bureaucracy to something that's supposed to be autonomous?
A: Yes, and that's the point. Autonomy without structure isn't freedom — it's chaos. The agents that feel 'autonomous' in demos are running in tightly controlled environments. Backlog just makes that structure explicit and reusable instead of hidden in someone's prompt.
Q: Do I actually need a separate tool for this, or can I just write better prompts?
A: You can write better prompts until your context window fills up and the agent forgets the original instructions. Backlog persists state outside the context window, so the agent can reference what's done and what's next without relying on memory that degrades over a long session.
Q: If AI agents need this much scaffolding, are they really better than just writing the code myself?
A: For simple tasks, no — just write the code. For multi-step refactors, cross-file changes, or anything that takes more than a few minutes, the scaffolding pays for itself. The contrarian take: most developers are using AI agents for tasks that are too simple to need them and too complex for them to handle without structure. Backlog targets the sweet spot in between.