There is a tension at the heart of AI-assisted development that does not get enough attention. AI can generate code faster than ever, but speed without structure creates a different kind of technical debt — one measured not in messy code but in missing context. No specification trail explaining why a feature exists. No plan record showing how the work was organized. No review artifact capturing what was checked before merging. When something breaks three months later, there is nothing to trace back to except a conversation that no longer exists.
This is not an argument against AI-generated code. It is an argument for wrapping it in the same engineering discipline we would expect from any well-run development process. Arness Code is our attempt at that wrapper. This post covers the plugin in detail. For the broader ecosystem, see Arness: Structured AI Workflows for the Full Development Lifecycle.
Five Entry Points, Three Ceremony Tiers
Arness Code organizes around five entry points that cover the development lifecycle. Planning starts a new feature or bug fix. Implementing executes a plan. Shipping commits, pushes, and opens a pull request. Reviewing addresses PR feedback. Assessing performs a deep-dive codebase health check. Each entry point chains to the next automatically — you do not need to remember the sequence.
Behind these entry points sits a scope router that evaluates the complexity of incoming work and suggests an appropriate ceremony tier. The swift tier handles small changes — a few files, minimal risk, done in a single session. It produces a lightweight change record and moves on with minimal overhead. The standard tier covers medium-scope features with a streamlined specification phase and task-tracked execution. The thorough tier is the full pipeline: multi-phase plans, dependency-aware task ordering, parallel execution, quality gates, and review loops.
The routing is automatic but not mandatory. You can override the suggestion. The system explains its reasoning so you can make an informed choice. The point is that a config file rename should not require the same process as a new payment integration, and a payment integration should not ship with the same oversight as a config file rename.
The Full Pipeline
The thorough tier illustrates the full depth of what the pipeline offers. It begins with specification — an iterative conversation with an architect agent that analyzes your codebase, identifies integration points, and helps you define what the feature actually requires. For features with significant UI components, a UX specialist joins the conversation. For security-sensitive work, a security specialist contributes threat analysis.
The specification feeds into planning, where a planner agent produces a phased implementation plan with file-level change descriptions, risk flags, and dependency ordering. The plan is structured into phases that can be reviewed before any code is written. This is the cheapest point to catch architectural mistakes — when the cost of change is a paragraph edit, not a code rewrite.
Execution dispatches tasks to specialist agents, with optional review gates between phases. Independent tasks can run in parallel. Each task produces a structured report. After execution, a simplification pass checks for duplication, missed reuse opportunities, and code that could be cleaner. An implementation review validates the result against the original plan and the project’s documented patterns.
Finally, shipping handles the Git workflow: branching, staging, committing with a structured message, pushing, and opening a pull request with a description generated from the artifacts that preceded it.
Every step produces a readable artifact. Every step is skippable. The pipeline adapts to what the work actually needs.
Patterns and Preferences
One of the quieter but more impactful features is pattern learning. On first use, Arness Code analyzes your codebase and documents its conventions — naming patterns, directory structure, import style, testing approach, architectural decisions. These patterns are stored as Markdown files in your project and referenced by every agent during code generation.
The effect is that AI-generated code looks like it belongs in your codebase rather than like it was dropped in from a tutorial. This matters more than it might seem. Inconsistent style erodes trust in AI-generated output and creates friction during code review. Pattern compliance is a small thing that compounds over many features.
Preferences work similarly. The first time the pipeline encounters a decision point — whether to run the simplification pass, whether to review the plan before execution, which ceremony tier to default to — it asks. After that, it remembers. Your workflow gets faster with each feature without losing the structural benefits.
The Batch Pipeline
For teams working on multiple features simultaneously, Arness Code offers a batch pipeline. Batch planning ingests several features at once, analyzes them in parallel, and produces plans for each. Batch implementation spawns isolated workers in separate Git worktrees, each implementing a feature independently and in parallel. Batch merge analyzes cross-PR conflicts and guides you through an optimal merge order. A final batch simplification pass checks for duplication across the newly merged features.
This is not the default path for most work. But for teams that have a backlog of well-defined features — particularly after a greenfield discovery phase with Arness Spark — it can compress what would be weeks of sequential work into a much shorter cycle.
Conclusion
The goal is not to slow down AI-assisted development. It is to make its output trustworthy — traceable from requirement to deployed code, consistent with the conventions of the codebase it lives in, and reviewable by the same standards we apply to human-written code. Structure is not overhead when it prevents the rework that unstructured output inevitably creates. Once code is ready to ship, Arness Infra picks up the deployment side of the lifecycle. Arness Code is open source and available on GitHub.