How to Make an AI Agent Run Fully Autonomously Through the Spec-Kit Implementation Phase?

Background: Why Does the Spec-Kit Workflow Stop Midway?

While using GitHub's Spec-Kit (a spec-driven development toolchain), a Reddit developer ran into a common source of confusion. Following the official documentation, he executed the full command sequence in order: /speckit.constitution, /speckit.specify, /speckit.plan, /speckit.tasks, and /speckit.implement. In theory, with all spec files (spec.md, plan.md, tasks.md) already generated, the AI Agent should be able to run through the entire task list in one shot, fully autonomously.

In practice, however, when reaching the implement stage, the AI Agent kept stopping to ask "should we proceed to Phase 2 / Phase 3?" — a far cry from the fully agentic behavior he expected. The developer's setup was a locally running Qwen model via LM Studio, paired with opencode as the client.

Is This Normal? The "Human Checkpoint" Design in Spec-Driven Development

From a Spec-Kit design philosophy standpoint, these mid-phase confirmations aren't entirely a bug — they're closer to an intentional safety gate. The core value of Spec-Driven Development lies in first decomposing requirements, plans, and tasks into human-reviewable documents, then having AI execute against those documents. The pauses between phases are essentially checkpoints, giving developers a chance to verify each stage's output before moving forward.

That said, the developer's desire is completely reasonable — if all the specs are already on disk, why not run straight through to completion? The key variables here are actually two:

1. The Model's Inherent Agentic Capability

He's using a small, locally deployed model (the post mentions Qwen, around 9B parameters). Smaller models tend to lack the "staying power" and context retention needed for long, multi-step autonomous task execution. They're more prone to frequently checking back with the user rather than confidently running through multiple phases in sequence. This isn't a Spec-Kit issue — it's a ceiling on the model's agentic capability.

"Agentic capability" refers to a model's ability to autonomously plan, invoke tools, execute multi-step tasks, and handle intermediate errors — all without requiring step-by-step human intervention. This capability is closely tied to model parameter scale, the quality of instruction-following samples in training data, and reinforcement learning alignment methods. A 9B-scale model is limited in how effectively it can utilize its context window and maintain stability across multi-step reasoning. When faced with long-chain tasks spanning multiple "Phases," these models are prone to "goal drift" — as conversation turns accumulate, the model gradually forgets or de-prioritizes the original objective and starts seeking human confirmation as a way to "avoid risk." By contrast, models with 70B+ parameters or those specifically fine-tuned for agentic behavior (such as the Claude series or GPT-4o) perform noticeably better at maintaining coherence across long tasks. Frequent phase confirmations, therefore, are often not a prompt or tooling problem — they're an outward sign of the model's own lack of confidence.

2. The Client / Runtime Environment's Agent Policy

Different Agent runtime environments vary widely in their default "autonomous execution" strategies. When opencode is paired with a local model, it tends to be more conservative.

A Useful Comparison: The Antigravity "Implement Mode" Experience

The author of the post added a valuable comparison. His workflow in Google Antigravity was "plan mode → implement mode," which is structurally very similar to Spec-Kit's plan/implement flow. But the experience was noticeably different:

In Antigravity, especially in CLI mode or Antigravity 2.0, once you choose implement mode, the Agent does everything it can to complete all the tasks in the plan — and only comes back to you once everything is done.

This comparison reveals an important conclusion: with the same "spec → implement" paradigm, the actual level of autonomy depends heavily on the underlying combination of Agent framework and model, not on the paradigm itself. Antigravity's ability to "run straight through" likely comes from a more powerful cloud-based model and a more aggressive autonomous execution scheduling strategy.

Google Antigravity (now rebranded as Jules) is an asynchronous AI coding agent from Google, similar in concept to GitHub Copilot Workspace. It's designed to autonomously complete an entire programming task in the cloud background — a developer submits a task and can walk away, returning later to review what the agent produced. This is fundamentally different from an opencode + local model architecture: Antigravity runs on Google's infrastructure, calling powerful cloud-based models specifically optimized for agentic behavior, with a scheduling system designed by default to "run through the entire plan and then report back" rather than confirm at each step. This architectural difference explains why the same "plan → implement" paradigm lets Antigravity "run straight through," while a local small-model-driven toolchain defaults to a conservative, step-by-step confirmation strategy.

How to Make Spec-Kit More Fully Autonomous

Based on this case, there are several angles to explore if you want a more continuous, autonomous execution experience with Spec-Kit:

• Upgrade your model: Replace the 9B-scale small model with a more capable one — either a larger local model or a cloud API. Agentic behavior typically improves significantly. Frequent confirmations from small models are largely a sign of low confidence.
• Adjust your runtime environment settings: Check whether opencode or your client of choice has settings for "auto-approve" or "continuous execution." Many tools allow you to reduce the frequency of manual confirmations.
• State your intent clearly in the prompt / constitution: In /speckit.constitution or your task description, explicitly declare something like "no need to confirm between phases — execute all tasks continuously until complete." This can sometimes guide the Agent to reduce mid-task interruptions.
• Accept that phased confirmation has its merits: For important projects, reviewing outputs at each stage can actually reduce the risk of AI going off the rails and causing large-scale rework. There's a real tradeoff between chasing "full autonomy" and maintaining "controllability."

The practice of stating intent explicitly in /speckit.constitution is essentially using a system-level prompt (system prompt) to redefine the Agent's default behavioral boundaries. Spec-Kit's constitution file functions like a "project charter" — it defines the rules and behavioral guidelines the AI should follow throughout the entire development process. Adding an instruction like "during the implement phase, do not seek user confirmation between Phases unless you encounter an unresolvable ambiguity or blocking error; otherwise, proceed through all tasks continuously until fully complete" can override the model's conservative defaults. Note, however, that such override instructions have limited effectiveness on weaker small models — the model may comply for the first few steps, then "forget" the rule as context depth increases. This is an inherent limitation of small models' instruction-following capability.

Summary

The "Agent stops midway to ask for confirmation" behavior this developer encountered is the combined result of a local small model and a conservative client configuration — not a design flaw in Spec-Kit. The phased confirmations in spec-driven development have genuine value. If you want to replicate the Antigravity experience of "select implement and run straight through," the key is upgrading the model's capability and adjusting the runtime environment's autonomous execution strategy — not simply modifying the command sequence.

For developers exploring AI-assisted programming workflows, this case is also a reminder: in an era when tool paradigms are converging, what truly determines the experience is almost always the underlying capability of the model and Agent framework.