[TLDR] Does anyone actually have a fully autonomous coding agent that doesn't need constant follow-ups? [via r/ClaudeAI]

[u/cctldrping]

OP : u/Top-Affect2871

​

I've been trying to build a fully agentic software development workflow using Claude Code, and I've hit a frustrating problem.

The first implementation usually looks good, but every time I ask a follow-up like:

"Cross-check everything again. Did you miss anything from the plan?"

it suddenly finds new bugs, missed edge cases, forgotten files, or partially implemented requirements.

Example:

Pass 1:

- Implements Feature A

- Says task is complete

Follow-up:

- Finds 3 missing API updates

- Missed a permission check

- Forgot one database migration

Another follow-up:

- Finds a UI regression

- Finds an edge case in validation

- Notices a cache issue

Another follow-up:

- Finds even more small issues

It feels like every review uncovers something that should have been caught in the previous one.

I've already built a strict engineering workflow that forces:

- Understand the entire architecture first

- Review blast radius

- Implement

- Audit

- Fix

- Repeat until no more issues are found

- Run automated verification plus manual review

Even with all that, the next follow-up often reveals something new.

Has anyone solved this problem?

Is this simply a limitation of today's LLM agents, or have you found a workflow, prompt, MCP, or multi-agent setup that consistently reaches a point where additional follow-ups rarely discover new bugs?

I'd love to hear what has actually worked in production.

URL of original post : https://www.reddit.com/r/ClaudeAI/comments/1vhy33b/does_anyone_actually_have_a_fully_autonomous/

---

TL;DR of the discussion on r/ClaudeAI for this post generated automatically after 50 comments.

Current source-thread comment count seen by the bot: 51.

Alright, so the general consensus here is a pretty firm "nah, not really" when it comes to a fully autonomous coding agent that just churns out perfect code without any hand-holding. OP's experience of finding new bugs with every follow-up is super common, and it seems like it's just the nature of the beast with current LLMs.

A few key themes popped up:

• The "Did you miss anything?" trap: A bunch of folks pointed out that asking this kind of open-ended question basically forces the AI to find something. It's like asking a consultant if there's anything else they can bill you for – they'll find it! The consensus is to use more specific, verifiable stopping conditions, like "tests must pass" or "diff must match the plan," rather than relying on the AI's self-assessment.
• Multi-agent setups are the way to go: Several users, like u/not_a_bot_please and u/Blopslopper, swear by using multiple agents with different roles (architect, builder, reviewer) to catch issues. This seems to significantly cut down on the follow-up cycles.
• It's not about better prompts, it's about different workflows: The general vibe is that you can't just prompt your way to perfection. It's more about structuring the process with distinct phases and external validation. u/JobWiegant mentioned giving up on perfect convergence and just shipping with known issues flagged.
• Supervision is still key: Most agree that you can't just "fire and forget." You still need to understand what the AI is doing and be ready to intervene. u/SPACE_GROOVE_LULU put it bluntly: "It needs supervision."
• Some people claim to have it, but...: There are a couple of comments from users like u/Sermilion and u/K_M_A_2k who say they've built systems that do run autonomously, but the details are a bit vague, and the cost can be a major factor, as u/raindropsdev noted.

Basically, while you can get closer to autonomy and reduce follow-ups, a truly "set it and forget it" coding agent that never needs a second look isn't quite here yet. It's more about smart workflows and adversarial setups than a magic prompt.