Anvil: How a Monorepo Unifies AI Coding and Development Workflows

The evolution of AI-assisted coding tools often prioritizes flashy demos over practical utility. Anvil, an open-source project born from a narrow developer need, now redefines how teams integrate AI agents into real-world software development. Unlike generic chat-integrated assistants, Anvil emerged as a specialized environment designed to bridge the gap between AI capabilities and grounded, repository-aware workflows.

Anvil began as a lightweight agentic coding harness, inspired by the concept of embedding AI agents directly into development projects. The original goal was simple: create a tool that could understand a repository, maintain context across tasks, and translate developer intent into implementable actions without scattering critical details across disparate tools. This first iteration deliberately avoided over-engineering, focusing instead on delivering tangible value for a specific use case—helping agents operate within software projects with sufficient precision to be useful and reviewable.

Over time, the project expanded beyond its initial scope, not out of scope creep, but because the boundaries between workflow, productivity, and context blurred into one cohesive need. The tool evolved to handle planning, implementation, review, and documentation in a single interface. Inspired by emerging AI features like Claude’s code review capabilities, Anvil introduced customizable rubrics that evaluate code changes against project-specific standards, offering developers a streamlined way to generate, post, or act on feedback directly within their workflow.

From Narrow Tool to Agentic Development Environment

The most significant shift in Anvil’s philosophy came with the adoption of the term agentic development environment (ADE). This concept frames Anvil as more than an AI assistant—it’s a centralized hub where work items, repository state, agent sessions, and development context converge. The original harness focused on running agents, but the ADE model aims to support the entire journey from problem identification to reviewed change:

• Understanding work items – Connecting tasks to their real-world context beyond ticket descriptions.
• Inspecting repository state – Providing agents with full visibility into code structure, dependencies, and constraints.
• Planning changes against constraints – Ensuring proposed solutions align with existing architecture and team conventions.
• Implementing with context – Enabling agents to generate code that fits within the project’s ecosystem.
• Running checks and reviews – Automating validation and feedback loops before changes reach human reviewers.
• Capturing reasoning – Documenting decisions and trade-offs for future reference.
• Linking outputs to systems – Ensuring changes are traceable back to their originating tasks.

This loop benefits developers directly, but its value extends to non-developers as well. Product managers can track changes and their rationale, testers can assess risks tied to specific code paths, and technical leads can review work without reconstructing narratives from scattered sources. The core ambition isn’t to replace human developers but to reduce the cognitive load of piecing together fragmented context.

Repository Awareness as the Foundation

At the heart of Anvil’s approach is repository awareness—the idea that AI agents must deeply understand the codebase they’re working in. Many AI coding tools operate on confidence rather than inspection, offering bold suggestions without scrutinizing the underlying project structure. Anvil rejects this model. Instead, it treats the repository as the primary grounding layer, ensuring agents have access to:

• The project’s file tree and current changes.
• Established conventions, scripts, and test suites.
• Documentation and local project rules.
• Historical context, such as migrations, deprecated patterns, or architectural boundaries.

This grounding is critical because work items alone are often incomplete. A ticket might describe a feature request, but the repository reveals the how—whether a change belongs in an existing module or if an abstraction is truly necessary. Anvil’s strength lies in holding these two perspectives—intent and implementation—together, so agents don’t operate in a vacuum.

Workspaces: A Shared Context for Teams

Anvil’s workspace concept borrows heavily from the design of VS Code, but extends it beyond mere editing. In VS Code, a workspace is more than a folder—it’s a cohesive operating context that bundles files, settings, extensions, terminals, and source control. Anvil adopts this philosophy but applies it to the broader development lifecycle.

A workspace in Anvil can encompass:

• The linked repository.
• Active work items and their metadata.
• Agent sessions and their outputs.
• Notes, drafts, and documentation.
• Automated checks and validation results.
• Project-specific configurations and environments.

This holistic approach matters because software teams rarely work on isolated repositories. They operate within a workspace shaped by the current project, branch, issue, environment, and release target. By preserving this shape, Anvil enables agents to function not just as tools, but as teammates that operate within the same frame of reference as the humans around them.

Anvil Registry: Addressing Supply-Chain Security

A parallel development within the Anvil ecosystem is Anvil Registry, a project born from a critical but often overlooked challenge: supply-chain security in dependency management. Commands like npm install conceal a vast amount of trust behind their simplicity. Behind the curtain, they can execute lifecycle scripts, pull in hundreds of dependencies, and introduce changes before anyone has vetted them.

This opacity creates significant risks—from typo-squatting attacks to compromised maintainer accounts or package-confusion vulnerabilities. Anvil Registry aims to bring transparency and control to dependency management by providing a centralized registry that:

• Scans dependencies for known vulnerabilities or suspicious patterns.
• Validates package integrity before installation.
• Tracks changes in dependencies across versions.
• Enables teams to define project-specific allowlists or blocklists.

While still evolving, Anvil Registry represents a pragmatic response to a growing problem: ensuring that AI-enhanced development doesn’t inadvertently amplify supply-chain risks.

The Future of Integrated Development

Anvil’s journey from a niche coding harness to a comprehensive development environment highlights a broader trend in AI tooling: the shift from standalone assistants to integrated platforms. The next frontier for Anvil and similar tools will likely involve deeper integration with development lifecycle stages—from deployment pipelines to incident response—while maintaining the clarity and context teams need to operate effectively.

As AI becomes more embedded in daily workflows, the real winners won’t be the tools with the flashiest demos, but those that reduce friction by unifying context, automation, and human oversight. Anvil’s approach—grounding AI in real repositories and human-centric workflows—offers a compelling blueprint for what’s possible when technology aligns with the realities of software development.