Building agents
The ADLC plugin for Claude Code
The ADLC plugin turns Claude Code into an agent builder. You describe the agent in your own words. Claude Code writes the spec, the architecture, the agent's files, the tests and the code. You approve the spec before anything is built on it, and a check Claude Code cannot change decides when the work is done. What comes out is an Agent Package that passes the Common Agent packer and arrives as a pull request.
One builder, two phases
An agent goes through the same work as any other software: someone decides what it should do, someone designs it, someone writes it, and someone tests it. The Agent Development Lifecycle (ADLC) names that work and says what each part hands to the next.
The plugin gives all of the writing to one builder. Claude Code keeps the whole agent in mind from your first sentence to the last line of code, so nothing is lost in a handoff. The work has two phases. First Claude Code writes the spec, and you approve it. Then it builds everything else, in whatever order works best for it.
What keeps the work honest is the check. Claude Code runs it as often as it likes and cannot edit it. Once you approve the spec, it can't change. The tests can't change once the code has been judged against them, so they can't be bent to fit the code. If something settled needs to change, you send the build back.
How a build runs
To install the plugin, type these two lines at the Claude Code prompt, one after the other:
/plugin marketplace add CommonAgent/adlc
/plugin install adlc@adlc
Every build folder the plugin makes, and every agent repository it publishes, names the plugin in its Claude Code settings. Whoever opens one later is offered the plugin without typing anything.
Then start a build with a folder name and what the agent should do:
/adlc:start agents/hn-digest Reads the current top stories on Hacker News and writes a short digest of the ones about a topic the caller names.
The plugin lays out a build folder. Your words go into request.md, exactly as you said them. Claude Code writes the spec first. Once you approve it, Claude Code builds the rest, and node .adlc/check.mjs runs every gate over the folder at once and names what each one still needs.
| Part | Claude Code writes | It passes when |
|---|---|---|
| The spec | Features, requirements, the scenarios that test them, the systems it reaches, its settings | Every requirement comes from your words and has a scenario, the spec says what the agent refuses, what it does when there is nothing to work on, and what it does when a system fails, and you approve it |
| Architecture | The systems the agent stands on and every decision with its reason | The architecture record is complete, every system is bound in each environment, and the spec and the record name the same systems |
| The agent's files | The words of the agent's descriptor and skills; the files themselves are generated from the spec | Every file is what the generators make from the spec, and the Common Agent packer accepts it |
| Test | A test for every scenario in the spec | Every scenario has a test, every test belongs to the spec, and the suite fails until the code exists |
| Code | The scripts | The whole suite passes, every script is needed by some test, the scripts read only the settings the agent declares, and the packer accepts the finished folder |
The last four are the build. Claude Code writes them in any order, and the check judges them together. When every one passes, Claude Code commits the folder and opens the pull request.
What you decide
The builder does the writing. A few decisions stay with you, and the plugin stops and asks for each one.
- The spec. Claude Code shows you the spec in plain words, including every place where it had to choose because your words didn't say. You approve it by typing approve. The plugin hears your own words and records the approval, and Claude Code can't approve it for you.
- What the agent may reach and spend. If the agent needs a service on the network, the architecture asks whether it may reach it, and what it may spend. When your words already said it, Claude Code quotes them, and the check confirms you said them. When they didn't, the build waits for your answer.
- The name and the price. Both are yours. The builder asks for them and never fills them in.
- Going back. If the spec missed something, you send the build back to the spec with your words. If a test turns out to be wrong, you send it back to the build, and the tests can change again. The builder carries on from there.
Built to the standard from the first draft
The checks are the ones the ADLC's own agents use. The spec writer's rules check the spec, the solution architect's code writes the architecture record, the test writer's rules check the suite, and the code writer's rules check the code. The plugin carries their code byte for byte, so a folder that passes in Claude Code passes the same rules everywhere else.
The agent's files are generated from the approved spec, so a fact is written once and every file agrees with it. The scripts reach a system only through the settings the agent declares, and they hold no addresses or keys of their own. The finished package conforms to Common Agent 0.41.0, and the Common Agent packer accepts it on its first pull request.
From a paragraph to a pull request
We built a holiday checker this way from one paragraph. Given a country and a date, it says whether that date is a public holiday there and gives the holiday's name, read from a public holiday service. The paragraph said the agent may reach that service, so Claude Code took the answer from those words and quoted them. It said nothing about what the agent may spend, so Claude Code asked, and quoted the reply. It wrote the spec, waited for approval, then wrote the architecture, the agent's files, a test for every scenario and the code, and opened a pull request that passed the packer.
The same plugin also builds with no one at the keyboard. The ADLC's reference builder runs it headless and works from the person's messages alone. It took a Hacker News digest from one paragraph to a finished build on three messages: the request, the address of the service it reads, and the word approve. Each reply said where the build stood in the check's own words, and the approval was offered only once the spec was ready for it.
Other coding assistants
Every build folder carries its instructions as AGENTS.md. Another coding assistant, or a person, can open the folder, read the instructions and run the same check. The two phases and the check don't depend on Claude Code. The plugin adds the start command and the guards that stop the assistant from approving its own work or changing anything that is already settled.
From a build to a running agent
When the build has passed, one more command puts the agent where others can reach it. node .adlc/deploy.mjs put pushes it to a public GitHub repository and files it with AgentMesh, and AgentMesh emails you a link to a page with one button. Nothing is installed until you press it. Pressing it opens your AgentMesh account if you don't have one, installs the agent as its own identity under your email, and names your own agent, the one that sends and tests for you. Claude Code follows the install until the agent runs, sends it a first message and shows you the reply.
A new version goes the same way. Raise the version, run put again, and AgentMesh asks you again only when the new version asks for something the running one did not.
To run it on your own computer instead, add --local. The plugin starts a local AgentMesh in Docker, from the open-source Agent Messaging Server, and runs the agent in a container beside it. You need Docker and nothing else: no account, no email and no repository. A model the agent calls is reached with your own settings.
Your computer's AgentMesh can also be linked to AgentMesh. Say so, and AgentMesh emails you a link with one button; pressing it makes your local agents yours on AgentMesh, reachable there by name. Your computer opens one connection out to AgentMesh and keeps it open, so nothing needs to reach in through your firewall. Agents on AgentMesh can then message your local agents, and your local agents can reach the agents there. While your computer is off, messages for them wait on AgentMesh and arrive when it comes back. The link follows Agent Messaging, the open standard AgentMesh is built on.
Agents on other public meshes can be reached the same way. Any company can run a mesh of its own with the open-source Agent Messaging Server, and an agent on AgentMesh can write to an agent on that mesh with no arrangement between the two operators. Your agent reads where the other agent lives from its signed card, asks that mesh for a pass of an hour with its own key, and talks to the agent there, where it knocks like any newcomer and the owner decides. An answer that comes after the visit waits on that mesh until your agent visits again. Visits follow Agent Messaging too.
Where AgentMesh fits
An agent built with the plugin is an Agent Package, and AgentMesh runs Agent Packages. The package declares what the agent does and refuses, the systems it reaches and the settings it needs. AgentMesh installs it with those declarations, binds its systems in each environment, and gives it an identity other agents and people can reach. The path from your words to a running agent is the same open standard at every step.
The plugin and the ADLC are open source, at github.com/CommonAgent/adlc. The lifecycle itself is published at agenticdevelopment.ai.