When AI coding agents ignore instructions, “done” isn’t enough

AI-generated code can be wrong without looking broken. The page loads, the feature exists, and the agent says the change is complete, but one of the requirements in the prompt is missing. That is the problem we're building Syntactor around.

We kept finding developers describing the same failure in much less polished language:

Different tools, same uncomfortable moment: the system says the work is done, but you still have to check whether it actually did what you asked. So we built a team.

One agent builds. The others look for what it missed.

Syntactor starts with your request, and one agent builds it. Then other agents get a different job, which is to review the result against what you asked for and look for missing scope. They are not asking whether they prefer a different abstraction, or whether they would rename a variable. They are asking whether the work actually covered the requirements.

When a reviewer finds something missing, it flags the requirement and the relevant part of the code, and the work goes around again with those findings attached. Then it gets reviewed again, and again if necessary. The loop stops when the reviewers find nothing left to flag. That is Syntactor.

Why not just tell the first agent to check its work?

You can. In fact, that is what most AI coding workflows already turn into:

Did you implement everything?
Check again.
You missed the loading state.
Fix that.
Now make sure you didn't break anything else.

At that point, you have become the review loop. You remember the original requirements. You notice what disappeared. You translate the miss into another instruction, ask for another pass, then inspect the result again. The coding agent generates, and you supervise.

Syntactor moves that work inside the team. The agent doing the implementation does not get to finish the task simply because it thinks the work is finished, since other agents still review the result against the request. Generation and review become different jobs.

“Fixed” should point to something

There is a big difference between:

Improved the signup flow.

and:

Rule 4 · loading state · SignupForm.tsx:86

The second gives the next agent something concrete to work from, and it gives you something concrete to inspect later. A flag stays connected to the requirement that caused it, so the next round inherits the code and the findings instead of starting another vague conversation about what “better” should mean.

So when the task comes back to you, you don't just get source code accompanied by the word “done.” You get the code and the record of what the team found and changed along the way.

Better prompts don't remove the need for review

Writing better prompts helps. Clear requirements, explicit constraints and good project context give a coding agent a better target. But a specification and a review process solve different problems: the prompt says what should happen, and the review asks whether it did.

A detailed prompt can still be partially implemented. An instruction can still be missed. A later rewrite can fix one requirement while dropping another. That is why the original request has to survive past generation, and why Syntactor keeps it as the target for the review. The prompt does not disappear into the chat history once code exists; it remains what the team checks the work against.

The problem is the gap between what you asked for and what came back

There are already tools for generating code, and there are tools for reviewing it, such as linters, tests and static analysis for finding different classes of problems. Syntactor is focused on a narrower question: did the implementation miss something you asked for?If your prompt asks for ten things and the result quietly contains nine, that is the failure we're interested in.

The reviewers find the miss, the next agent rewrites against it, and the whole thing gets reviewed again. If the reviewers find nothing left to flag, the task passes. If the team reaches its give-up limit without getting there, it never passes and you pay nothing. That's the model.

Stop being the review loop

The strange part of AI coding today is that generation has become cheap, but checking whether the generation actually followed the request is still largely your job. You prompt, it builds, you inspect, you find the miss, you explain it again, it rewrites, and you inspect again.

Syntactor is built to take that loop off your desk. Give the team the task, let one agent build it, and let the others try to find what it missed, so that the work only comes back to you when they have nothing left to flag.

Early access

We're opening Syntactor to its first users. Early access is free while we build, and when charging begins, tasks that never pass cost nothing. If you're tired of being the person who has to notice that the coding agent quietly skipped requirement number six:

Request early access→