This coding agent doesn’t want your feedback — it ships without it

Darryl K. Taft · article · 2026-06-01 source ↗ Reader 🖥️

practical · mixed — Primarily a product-launch profile (expository), but organized around an explicit architectural thesis — that AI coding tools should be built as closed-loop, developer-optional systems rather than faster chat loops — which the piece argues for via Verlaguet's quotes and the mechanics of what Skipper does. Practical because the upshot is 'build/use tools this way,' not merely 'here is what is true.'

Structure

Key terms

• closed loop Closed-Loop Coding Agents (Compiler-Style vs. Chat-Style)
  The prompt → generate → validate → fix cycle runs entirely inside the agent itself (model plus deterministic runtime and type checker), with no exposed step where a developer reviews or refines the output before it ships. Contrasted explicitly with Claude Code, Cursor, and Codex, which keep the developer inside that same cycle turn by turn.
• reactive runtime
  A runtime (descended from the Skip language Verlaguet built at Facebook) in which a program is defined as a declarative graph of computation from inputs to outputs; the runtime automatically handles state management, cache invalidation, and concurrency, so the AI model generating the service never has to reason about what happens when one part of the state graph changes and another depends on it.
• architecture problem disguised as a coding problem
  The recurring claim that correctness in software has always depended on structural decisions (how state, concurrency, and data flow are organized) rather than on the surface skill of writing individual lines of code — and that AI does not change this underlying reality, it only raises the stakes because AI can generate incorrect-but-plausible code far faster than architecture can be gotten right by prompting alone.
• guardrails Guardrails
  Verlaguet uses the term narrowly and critically: real guardrails are deterministic tooling and runtime infrastructure built from scratch to structurally bound AI behavior (e.g., a reactive runtime that makes certain classes of bugs impossible), as opposed to what he says most competitors actually ship under that label.

Propositions

• explicitBuilding correct software has always been an architecture problem disguised as a coding problem; AI did not change that, it just made the problem more urgent.conf: high
• explicitcontestedThe next generation of AI coding tools should make the developer's involvement in the loop optional, by running the review-and-refine pass inside the agent instead of between the agent and a human — 'closed loop' is a different theory of what a coding tool is for, not a feature bolted onto the current one.conf: high
  contradictsAgentic Code Review · p12 — Skipper's framing claims the developer's involvement becomes 'optional' and the review cycle is removed entirely, whereas agentic-code-review argues the human never actually leaves the loop — only moves up a level to specification, acceptance, and accountability — which is arguably a more accurate description of what Skipper's own mechanics (developer supplies the prompt/spec) actually require.
• explicitState management and concurrency are where AI-generated code most consistently fails, and the correct fix is structural — a runtime that manages state, cache invalidation, and concurrency automatically — not a prompting-based fix.conf: high
• explicitMost companies claiming to build AI guardrails are actually just doing more prompting; almost no one is building real guardrails and tooling from scratch, because that is a lot of work.conf: high
• explicitAs AI models get faster, code-verification tooling must become incremental — able to re-check a changed diff without restarting from scratch — because CI-speed batch validation (30–60 minutes) will become an intolerable bottleneck.conf: high
• implicitdevelopedA closed loop that type-checks its own generated code and automatically retries fixes up to a bounded budget (eight attempts) before returning a result is reliable enough to ship a working service without a human reviewing the code in between.conf: medium
  extends ←Case Study: Refactoring at Scale with Agents · p3 — Both describe a closed-loop agent pattern (deterministic feedback, bounded autonomous iteration), but this case study demonstrates it at far larger scale and with a richer verification oracle (frame-exact replay-trace equivalence) than a type-checker-and-retry loop.
• implicitTreating foundation models as an interchangeable, routable commodity — rather than anchoring the product's trust story in any one model's quality — implies that the trust-bearing work in a coding agent belongs to the deterministic system around the model, not to the model itself.conf: medium

Arguments

Narratives

• The step-by-step account of what happens on a single Skipper run: receive a prompt, generate an OpenAPI spec from it, build the full service (routes, data mappers, validators, TypeScript types, unit tests), run it in a Docker container, and — if generated code fails type checks — fix it, up to eight attempts, before returning a result, all without a developer watching.
  → Makes the abstract 'closed loop' key term concrete, and implicitly argues that 'no review cycle' does not mean 'no verification' — verification still happens, just mechanically and internally (type checks, container execution) rather than through human judgment.
• The comparison to React: 'the same idea applied to a backend service instead of a UI' — JavaScript handles the computation links between graph nodes, while the Skip runtime manages everything below that.
  → Supports the 'reactive runtime' key term by borrowing credibility from a proven, familiar pattern (React's declarative UI reactivity), implicitly arguing that an equivalent reactive substrate for backend state is a precedented engineering bet rather than a speculative one.

Questions addressed

• ✅ What has the AI coding tool industry gotten wrong?
  It has optimized developer speed inside a human-reviewed chat/iteration cycle, when the actual failure mode of AI-generated code (state management and concurrency) requires a structural fix and removing the human review step, not a faster version of it.
• ✅ Why do most competitors' 'AI guardrails' claims fail to deliver real guardrails?
  Because building real, deterministic guardrail tooling from scratch is a lot of work, so competitors default to prompting instead and market it as guardrails.
• ⭕ What happens when Skipper's internal fix loop cannot resolve a type error within its eight-attempt budget?
• ⭕ Does removing the developer from the loop generalize beyond typed backend/API service generation — e.g., to UI code, algorithmically novel logic, or under-specified requirements — or is it scoped to domains where a comparable reactive, typed substrate already exists?

Gaps

• illogicalThe article states that Skipper makes the developer's involvement 'optional' and removes review/iteration/back-and-forth entirely, while the same paragraphs describe the developer supplying the prompt or OpenAPI spec that determines what gets built — and, implicitly, deciding afterward whether the resulting service is fit to deploy. The developer has not left the loop; they have moved to its specification and acceptance ends. The piece never acknowledges this as anything short of full removal, an equivocation between 'the review-and-refine sub-loop is internalized' (true, and interesting) and 'the developer's involvement is optional' (overstated, given the developer still authors the input and presumably judges the output before it ships to production).
  Read next: extract-agentic-code-review's proposition that 'the human does not leave the loop but moves up a level ... human-in-the-loop becomes human-on-the-loop' names exactly this dynamic and is a useful direct comparison; also worth reading anything Verlaguet or SkipLabs publish post-launch about how developers actually validate and accept Skipper's output before deployment.
• incompleteThe article never explains what happens when Skipper's internal fix loop exhausts its eight attempts without passing type checks — does it return the last broken candidate, surface an error to the developer, or fail silently? Without an answer, 'ships without your feedback' is a claim about the happy path only; the framing hides an unspecified failure mode at precisely the point where developer judgment would otherwise matter most.
  Read next: A technical writeup, postmortem, or incident report on Skipper's real production failure behavior; more generally, material on retry-budget exhaustion and failure disclosure in agentic code-fix loops.
• incompleteThe correctness claim rests entirely on type checks passing and the service running in Docker; it never addresses whether type-correct, running code is also semantically correct — i.e., whether it does what the developer actually intended. Type safety and intent-fidelity are different guarantees, and the article treats passing the former as sufficient evidence of the latter.
  Read next: Material on the gap between formal/type conformance and intent conformance in AI-generated code — e.g., discussions of formal methods noting a formal specification can be precisely wrong, or corpus material on what counts as sufficient verification for AI-generated code.

Related documents

• Agentic Code Review
• The New SDLC With Vibe Coding: From ad-hoc prompting to Agentic Engineering
  Coding Agents Guardrails Model Routing
• The Pulse: Interesting AI coding stats from Cursor
  Coding Agents Human-in-the-Loop Model Routing
• A cautionary tale about AI in tech writing: Why "Trust but Verify" is the only way to scale
  Guardrails Human-in-the-Loop Verifiability (as the Quality Bar)
• 11 Tips For AI Coding With Ralph Wiggum
  Guardrails Human-in-the-Loop
• Software Factories, Light and Dark
  Human-in-the-Loop Verifiability (as the Quality Bar)
• Agent Skills: Google-Backed AI Coding Agent Workflow
  Coding Agents Guardrails
• Have your agent record video demos of its work with shot-scraper video
  Coding Agents Human-in-the-Loop
• Article: Agentic Fitness Functions: Extending Evolutionary Architecture Beyond Deterministic Rules
  Guardrails Human-in-the-Loop
• Your AI agent just blamed the network team. Now what?
  Guardrails Human-in-the-Loop