AI coding agents have become an increasingly important part of my software development workflow. As I've gained experience working with them, I've spent considerable time examining how established software engineering practices can be incorporated into an environment where agents perform much of the implementation work.
I've been developing a collection of engineering skills, workflows, and standards to support that process. What initially began as a way to establish greater consistency in my own development practices has gradually evolved into a larger open-source initiative called Builder Garage.
Builder Garage is a project-embedded, extensible agentic engineering framework intended to support responsible software construction with AI agents. Its development focuses on the engineering processes surrounding implementation, including discovery, architectural decisions, review, verification, and delivery.
The project is still in its foundation stage, but enough of the operating model and supporting infrastructure has been developed to begin sharing the approach with other builders.
Who Builder Garage Is For
When discussing agentic software development, much of the attention tends to focus on increasingly autonomous systems, multiple agents working together, and the emergence of software factories. These are interesting developments, and some of the concepts being explored through Builder Garage may eventually support more sophisticated agentic environments.
However, I don't believe a builder needs to operate a collection of specialized agents or construct a software factory to benefit from established engineering practices.
Someone developing an application with a single AI coding assistant can encounter many of the same challenges involving requirements, design decisions, code quality, and maintainability. An individual developer may need a consistent discovery process, reusable implementation instructions, or a better approach to reviewing AI-generated code.
An experienced engineer working with a small team may have additional concerns about architectural consistency, engineering standards, and coordinating changes across contributors. Other builders may be experimenting with specialized agents and more elaborate workflows.
Builder Garage is intended to be useful across these different development environments.
Because the project is open source, builders are also free to adopt individual artifacts without adopting the entire framework. Someone might find a discovery skill useful and incorporate it into an existing workflow. Another developer might adopt one of the technology manuals or adapt a review procedure to suit a particular project.
There is no requirement to install the complete framework simply to make use of those resources.
For builders who want to adopt Builder Garage as an engineering framework, the project provides a more structured operating model, including configuration, responsibilities, engineering contracts, and verification practices.
The distinction is important because the engineering needs of a project should help determine the tools and practices used to support it, rather than requiring builders to introduce complexity that serves no meaningful purpose.
The Engineering Challenges
One of the things I've encountered while working with coding agents is how easily implementation can move ahead of the processes needed to evaluate it.
An agent can receive a development task, produce an implementation, execute tests, and report that the work is complete. Depending on the task and the context provided, that implementation may be entirely acceptable. However, there are also situations where the code works but doesn't align with the intended architecture, introduces unnecessary complexity, or fails to account for requirements beyond the immediate task.
These aren't entirely new software engineering problems. Developers have been dealing with requirements ambiguity, architectural consistency, code quality, and verification for decades. What's changing is the pace at which implementations can be produced and the degree to which portions of the work can be delegated.
I've also found that the instructions provided to agents can become repetitive. Expectations around discovery, coding standards, implementation boundaries, and review procedures often apply across many different tasks. Repeating those expectations in every prompt is inefficient, and relying on the person directing the work to remember every instruction introduces opportunities for inconsistency.
Agent skills provide a useful mechanism for addressing some of that repetition by making engineering procedures reusable. But having a collection of skills doesn't automatically establish how those skills relate to one another, when they should be used, who is responsible for a particular activity, or what evidence is required before work can proceed.
These are some of the concerns Builder Garage is intended to address.
The Builder Garage Operating Model
The operating model distinguishes among three things that are often combined in conversations about AI-assisted development: the engineering task, the procedure used to perform the work, and the instruction that initiates the activity.
In Builder Garage, GitHub issues and pull requests provide the durable record of what needs to be accomplished, along with scope, requirements, acceptance criteria, and the history of engineering work performed.
Skills define how a particular engineering activity should be conducted. They establish procedures, responsibilities, boundaries, and completion requirements that can be reused across tasks.
Prompts provide the immediate instruction to perform an activity, identify the relevant context, and invoke the appropriate skill.
For example, a GitHub issue might describe a change needed in an application's authentication process. The issue establishes the requirements and the expected outcome. An implementation skill governs how an agent approaches the work, including adherence to scope and engineering expectations. The prompt identifies the issue and instructs the agent to perform the implementation using that skill.
This separation allows engineering procedures to evolve independently of the individual features or defects being addressed.
It also provides a way to preserve information that would otherwise remain confined to an agent's conversation. Discovery findings, implementation records, and review outcomes are documented in the appropriate GitHub issues or pull requests so that subsequent engineering activities can reference them without depending on the original chat session.
How a Typical Engineering Workflow Operates
To illustrate how these practices fit together, consider a developer using an AI coding agent to implement a feature in an existing application.
The work begins with a GitHub issue describing the requested functionality, relevant constraints, and acceptance criteria. The issue provides the context for the change and becomes the durable record of the engineering activities associated with it.
Before implementation, the developer or agent determines whether additional discovery is necessary. If the requirements are sufficiently understood, implementation can proceed. If there are unanswered questions involving existing architecture, dependencies, or expected behavior, a discovery workflow can be used to investigate those concerns.
The findings are documented in the originating issue so they remain available to subsequent activities.
During implementation, the agent follows the applicable engineering skill and standards. Its responsibility is to implement the change within the established scope, document the work, and prepare the completed implementation for review.
The implementation is then evaluated independently. In Builder Garage's current operating model, the agent responsible for implementation cannot also serve as its independent reviewer. The review takes place in a separate execution context and examines the completed work against its requirements and relevant engineering expectations.
If the review identifies problems, the implementation returns for correction and subsequent re-review. Once independently approved, the change can proceed toward a pull request, where additional checks and human acceptance determine whether it should be integrated.
Throughout the process, the issue and pull request preserve the relevant engineering records.
This workflow doesn't require a software factory or an autonomous orchestration system. A developer could perform these activities using an AI coding assistant, invoking the appropriate skills in separate sessions and maintaining the required records in GitHub.
The objective is to make the engineering process repeatable and verifiable while retaining human responsibility for the direction and acceptance of the work.
The Architecture
Builder Garage is organized around five conceptual areas that represent different responsibilities within the engineering process.
Workbench is concerned with reusable engineering skills, workflows, procedures, and tools. This is where the practices used to carry out development activities fit within the broader system.
Crew addresses the responsibilities and boundaries of agents participating in engineering work. A central consideration is how different roles interact while preserving appropriate separation between implementation, review, and other activities.
Inspection focuses on independent reviews, testing, acceptance verification, and quality gates. Its purpose is to establish whether completed work satisfies the requirements and engineering expectations associated with it.
Shipping concerns the movement of accepted work through integration and delivery. This includes pull request requirements, release readiness, deployment considerations, and the conditions under which work may be promoted.
Manuals provides maintained technical guidance for working with particular technologies. The current collection includes C# / .NET, Go, and Python, each containing practical design and coding conventions for its respective technology.
Manuals are intended to provide reusable guidance while allowing individual projects to make their own architectural and implementation decisions. Projects explicitly select which manuals to adopt, and those selections become part of their configuration. The guidance can then be made available to coding agents through the framework's skill installation process.
An important distinction is that manuals provide technical guidance rather than mandatory engineering rules. Projects can document departures from the recommended conventions without those departures automatically being treated as engineering defects.
These areas are currently conceptual boundaries rather than fully implemented software components. Their documentation establishes responsibilities and relationships, while the implementation of additional capabilities remains part of the project's ongoing development.
An important architectural decision is that Builder Garage is intended to operate within the projects that adopt it, rather than requiring a separate hosted platform. The initial implementation follows a CLI-first approach, with project-level configuration and reusable skills serving as the foundation.
The goal is for the framework to support different project environments and engineering needs without requiring every project to follow an identical configuration.
Engineering Responsibilities and Independent Review
One area receiving particular attention is how engineering responsibilities are separated and verified.
In the current operating model, the agent responsible for implementing a change does not perform its independent review. Implementation and independent review take place in separate execution contexts, with each role responsible for producing its own records.
This is an important distinction because having an agent evaluate its own implementation doesn't provide the same separation of responsibility as an independently conducted review.
The review is concerned with whether the implementation satisfies the requirements, conforms to relevant engineering expectations, and introduces defects or other problems that need to be addressed.
If corrections are required, the corrected implementation must be reviewed again. Approval of an earlier version doesn't automatically apply to subsequent changes.
Builder Garage also distinguishes between independent engineering review and human acceptance. A technically acceptable implementation may still fail to satisfy the intended product outcome. The project's governance therefore retains explicit human authority over acceptance of product intent and decisions about whether a change should be integrated.
These requirements are documented in what Builder Garage calls its responsibility floor, a set of engineering rules that cannot be weakened through project configuration. Other aspects of the workflow can be adapted through explicitly defined extension points.
This model is intended to provide consistency in essential engineering responsibilities while allowing projects to make appropriate decisions about their own development practices.
It is also important to distinguish the operating contracts from automated enforcement. At this stage, the system relies on agents and contributors following the documented procedures and recording their work. The CLI can inspect some of that evidence, but it does not certify that separate agents actually operated independently.
The Initial CLI Foundation
The first executable component of Builder Garage is the garage command-line interface, implemented in Go.
The CLI provides a starting point for introducing Builder Garage into a project. Its current capabilities include initializing and validating project configuration, managing configuration values, installing and verifying engineering skills, recording developer-local workflow events, and examining workflow status using information recorded in GitHub.
Project configuration is maintained in .garage/config.yaml. This file records the choices a project makes at the framework's supported extension points, including relevant workflow and responsibility settings.
For example, after building and installing the CLI from source, a project can use the following commands:
garage init
garage config validate
garage skills install
garage skills verify
The initialization process guides the user through the required configuration choices. The validation command checks whether the resulting configuration conforms to the supported schema and constraints.
The skills commands install the canonical engineering skills and any adopted manuals at the project's configured agent-harness locations, then allow the installation to be verified.
Another command, garage status, reads the workflow records associated with a GitHub issue or pull request and reports what the available evidence indicates about its progress.
The CLI is deliberately limited in scope at this stage. It does not execute engineering workflows, invoke agents, coordinate autonomous activity, or provide integrations with AI model providers.
Those distinctions are important because Builder Garage is not currently an autonomous software factory. It is an evolving engineering framework with a working CLI foundation and a collection of reusable engineering practices.
Future capabilities will be introduced as their requirements are established and evaluated.
Maintaining Appropriate Engineering Structure
One of the considerations influencing Builder Garage's design is the relationship between engineering discipline and unnecessary process.
I've encountered situations where AI agents introduced more complexity than a task required. I've also experienced development workflows becoming increasingly elaborate as additional instructions, validation steps, and requirements were introduced.
The framework itself needs to avoid the same problem.
Not every development task requires an extensive discovery investigation, and not every change introduces the same degree of uncertainty. The operating model allows discovery to be performed when warranted rather than requiring an identical discovery process for every task.
At the same time, there are engineering responsibilities that should remain consistent, particularly around independent review and preserving reliable records of work.
Determining which practices should be mandatory, which should be configurable, and which should remain guidance is an ongoing part of the project's development.
The intention is not to maximize the number of agents, workflows, or approval steps. It is to establish engineering practices that are useful, repeatable, and appropriate to the work being performed.
Building in the Open
Builder Garage is being developed publicly under the MIT License, with a maintainer-led, community-contributed governance model.
The repository contains the current engineering skills, architectural direction, responsibility rules, project documentation, CLI implementation, testing infrastructure, and contribution procedures.
I want the development process to remain visible, including the questions being investigated and the decisions that emerge from that work. Architectural decisions are documented, and changes to the framework follow the same engineering practices that Builder Garage is intended to support.
This also creates opportunities to evaluate the framework through its own development rather than treating its practices as theoretical recommendations.
There are still substantial areas to explore, including the evolution of the conceptual components, support for additional project environments, extension mechanisms, and possible future approaches to agent coordination.
I don't want to prescribe the detailed architecture for capabilities that haven't been sufficiently investigated. The approach is to establish direction, evaluate requirements through discovery, implement what is supported by the evidence, and revise when experience demonstrates that a different approach would be more appropriate.
Opportunities to Contribute
I'm interested in engaging other engineers and builders who are exploring similar questions about agentic software development.
Contributions can involve implementing scoped features, reviewing engineering procedures, examining architectural decisions, improving documentation, identifying gaps in the operating model, or sharing experience from other development environments.
The project has a documented contribution process, including guidance for first-time contributors. Changes generally begin with a GitHub issue, proceed through implementation and independent review, and require maintainer approval before being merged.
Developers interested in participating can review the repository's open issues, particularly those marked good first issue or help wanted. Contributors are asked to request assignment before beginning work on an existing issue to help coordinate development efforts.
I recognize that different builders will approach these problems with different tools, workflows, and levels of experience. Those perspectives are valuable, particularly while the project is still developing its foundations.
Builder Garage is an opportunity to investigate how established engineering practices can be applied, adapted, and extended as AI agents become a more significant part of software construction.
The framework is still evolving, and I'm interested in learning what works, what needs refinement, and where other approaches may provide better results.
For those interested in exploring the project or participating in its development, the repository and contribution documentation are available on GitHub.
Builder Garage: https://github.com/bdonaldharris/builder-garage
Contribution Guide: https://github.com/bdonaldharris/builder-garage/blob/main/CONTRIBUTING.md
B Donald Harris
Top comments (0)