From conversational helpers to compiler-based development
AI coding agents are autonomous code generation systems that accept a high-level description of desired software and return running services, shifting from feedback-driven chats to compiler-based development where the agent behaves more like a deterministic build tool than an interactive assistant. For years, the industry has focused on accelerating “prompt, review, refine, repeat” workflows, assuming the main bottleneck was typing speed. Julien Verlaguet, founder of SkipLabs and creator of the Hack language, argues this has been the wrong problem: building correct software is an architecture challenge, not a prompt-writing exercise. In this new framing, the goal is not to co-write code with an AI, but to describe intent once and let an autonomous pipeline plan, generate, type-check, run, and validate the result, with humans stepping in only when requirements change or the agent fails entirely.
Skipper’s closed loop: autonomous code generation as a pipeline
SkipLabs’ Skipper is a prominent example of this compiler-style approach to AI coding agents. Instead of leaving developers in the loop, Skipper runs the entire review cycle inside the agent. The tool takes a plain-language description or an OpenAPI specification, generates an OpenAPI spec if needed, then builds a complete backend: routes, data mappers, validators, TypeScript types, and unit tests. It compiles and runs the service inside a Docker container, fixing type errors up to eight times before returning a result. Skipper also integrates external services, calling APIs and working with live data without human step-by-step supervision. According to The New Stack, “the current generation makes the developer faster. The next generation makes the developer’s involvement optional.” In this model, foundation models are treated as interchangeable APIs, while correctness and state handling are enforced by the surrounding runtime and tooling.
Determinism, perfectionism, and the Zig perspective on AI tools
Compiler-like AI workflows intersect sharply with long-standing debates about determinism and correctness in programming language design. Andrew Kelley, creator of the Zig language, is outspoken about non-deterministic AI tooling: he objects that AI-generated contributions are unteachable, non-deterministic, and “invariably garbage” for a project that values mentoring contributors into long-term maintainers. Zig’s code of conduct bans AI contributions and the project chases what Kelley calls “uncompromising perfection” before declaring a 1.0 release, even if that means many breaking changes and a long pre-1.0 lifecycle. From this perspective, tools that behave like compilers must earn the same trust as compilers: deterministic behavior, repeatable output, and no surprises hidden behind probabilistic models. The tension emerges when autonomous agents promise speed but cannot guarantee the perfectionist bar Zig sets for language behavior and tooling reliability.
Rethinking coding tool philosophy and the economics of AI subscriptions
Skipper’s architecture reflects a broader coding tool philosophy: models are commodities, while correctness lives in the runtime, type system, and orchestration around them. The agent treats foundation models as simple APIs and reserves “intelligence” for how services are structured, how state is handled, and how code is validated before shipping. This stands in contrast to cloud-hosted, subscription-based assistants that keep developers in constant dialogue with a remote model. Kelley is skeptical of such offerings, saying he will not trade running code on his own computer for “closed-source programming on someone else’s computer through the network” that he must pay for monthly. Critics see this as an economically unsustainable proposition: renting probabilistic assistants indefinitely, instead of investing once in deterministic, compiler-like agents that run locally or in controlled environments and can be trusted to ship without endless feedback cycles.