Table of Contents
Overview
Guild Plugin is a Claude Code plugin that builds a dedicated agent organization for each repo to do the development work — and makes that organization grow on its own. The previous posts covered how this organization is structured and how it develops. This post is where things get real: how does the organization actually grow itself — the growth engine.
Guild Plugin grows three things together (co-evolution): ① the output (the codebase), ② the developer (the agent organization itself), and ③ the overseer (the human using the tool). This third post in the series covers ① and ②, the process by which the output and the organization grow together. The third axis — people (③) — and the safety model come in Part 4.
Guild Plugin’s source code and installation instructions are available in the dev-yakuza/deku-claude-plugins repository.
This post is Part 3 of the Guild Plugin series.
- Part 1. Growing an Organization, Not Just a Skill — why I built this
- Part 2. The Structure of an Agent Organization and Its Development Flow
- Part 3. The Growth Engine ①② — Co-Evolution of Output and Developer (this post)
- Part 4. The Growth Engine ③ + Safety — The Overseer (Human) Grows Too
The Developing Loop and the Growing Loop
Guild Plugin runs on two loops.
- Development Loop (Inner Loop) — the flow that develops a single issue: analyze → design → implement → test → QA. It runs on every task, and each run accumulates the ① output (codebase).
- Growth Loop (Outer Loop) — the flow that reads the traces left behind during development to improve the organization that does the developing. It runs occasionally, and each run grows ② the developer (the organization).
Most AI tools only have a development loop. They produce code, but the tool that produces the code stays exactly the same. What sets Guild Plugin apart is exactly this growth loop.
Two commands drive the growth loop. /gld audit is the health check that diagnoses the organization’s condition, and /gld evolve is the actual growth that builds the organization up. This post is about evolve.
The Raw Material for Growth Is Traces
Just as a human organization grows through retrospectives, Guild Plugin grows through traces — signals that naturally accumulate during development.
- Human corrections — cases where a person overrode an agent’s judgment with a different choice.
- Reverts — cases where a change made with confidence was later rolled back.
- Verification gaps — cases where something was reported as “passing” but the actual execution result said otherwise.
- Repeated friction — cases of hitting the same error, rediscovering the same thing, or explaining the same point over and over.
There’s one strict rule governing all of this: every trace must be grounded in actual outcomes (ground truth). It has to be tied to an objective fact — test results, gate results, CI results, an actual defect that occurred, or an actual human action (a correction or a revert).
An AI’s own self-assessment that “I did well” is not a valid trace. Without this rule, the AI would grow however it pleases — grading itself generously along the way. That’s why Guild Plugin never treats self-assessment as grounds for growth; only judgments made by a different role than the one that produced the work, or corrections made by a human, count.
Turning Traces Into Habits, Knowledge, and Rules
evolve distills the collected traces into three forms — much like how a human organization settles experience into habits, documentation, and rules.
- Habits — a pattern that a specific role keeps getting corrected on becomes a habit of that role agent. For example, if the developer role keeps breaking a certain rule, that rule gets etched into the developer role’s definition, so it’s followed from the start the next time around.
- Knowledge — code facts discovered during development (these files tend to change together, watch out for this pitfall here) get recorded as knowledge shared by the whole organization. Nobody has to waste time rediscovering the same thing later. And because this knowledge is shared, it doesn’t disappear even if a specific role later changes.
- Rules — rules that are hard to catch with tests get promoted into commit-gate rules. Something a human used to correct by hand every time is now blocked automatically by machine.
There’s an interesting analogy here. While awake, humans hold what they experience in working memory, then while asleep, consolidate the important parts into long-term memory. evolve works similarly: traces from development accumulate as low-confidence “working memory,” and when evolve runs, only the verified ones are consolidated into the “long-term memory” of habits and knowledge. Unverified traces never become the organization’s authoritative knowledge on their own.
HR Management, Like a Real Organization
The place where the concept of “organization” shows up most clearly in the growth loop is HR. Guild Plugin manages its members the way a human organization would.
- Hiring — a specialist role that keeps getting needed repeatedly gets activated as a standing member, or a new agent gets created if necessary. (A repo with frequent security issues gets a security role as a regular member.)
- Retirement — a role that never gets called up gets archived in a recoverable form. The organization’s knowledge is a shared asset and doesn’t disappear; what leaves is only the habits unique to that role. So retirement never results in knowledge loss.
- Replacement — a role that keeps consistently underperforming gets let go and rebuilt.
- Promotion — a verified habit gets elevated into a stronger rule (a gate), or gets contributed to the central plugin so other repos’ organizations can use it too.
And behind every one of these decisions sits a scorecard (360-degree review), which tracks each role’s performance based on the ground truth mentioned earlier. But just as no one gets fired over a single bad outcome, Guild Plugin’s HR decisions only move once a trend has accumulated — no judgment is made from a single run.
Growth Is Never Reckless
An AI that modifies its own code can be dangerous. Grow it the wrong way, and it does more harm than good. That’s why Guild Plugin’s growth is strictly verified. (The full safety model is covered in Part 4; here I’ll just hit the key points.)
- Human approval — every change requires item-by-item human approval before it’s applied. Nothing is ever applied automatically.
- Adversarial verification — before a change is applied, an independent review panel with no prior context tries to argue that the change is wrong. Any change that can’t survive that pushback is discarded.
- Reversibility — every applied change comes with a backup, a rollback path, and a history record, so it can always be undone.
- Only when there’s enough evidence — if the traces are too thin,
evolvesimply refuses to grow. The principle: better not to grow at all than to grow wrong on shallow data. - Verification never gets weakened — no growth is ever allowed to move in a direction that weakens tests or verification. This rule has no exceptions.
Co-Evolution of Output and Developer
Now you can see how the output (①) and the organization (②) grow together. They aren’t independent — each one is good raw material for the other’s growth.
- A good organization (②) produces good output (①).
- The process of producing that output leaves traces behind.
evolveuses those traces to improve the organization (②).- The improved organization produces the next output (①) even better.
This cycle is co-evolution. The output and the developer lift each other up within a single loop — a compounding force that a static tool simply doesn’t have. The longer it’s used, the more specialized a repo’s organization becomes to that specific repo, producing better results with fewer corrections along the way.
Wrapping Up
To sum up, here’s how Guild Plugin’s growth loop (evolve) works.
- It collects traces left behind during development, but only ones grounded in actual outcomes (self-assessment excluded),
- distills those traces into habits, knowledge, and rules,
- grows the organization through HR — hiring, retirement, replacement, promotion,
- and keeps it all safe through human approval, adversarial verification, and reversibility.
The result: the output (①) and the developer (②) co-evolve — an organization that gets smarter the longer you use it.
But there’s still one axis left: ③ the overseer, the human using the tool. Remarkably, Guild Plugin tries to grow not just the code and the organization, but the human too. Part 4 covers that third growth engine, along with the safety model underpinning all of this self-growth.
Guild Plugin is available on the deku-claude-plugins marketplace.
Was my blog helpful? Please leave a comment at the bottom. it will be a great help to me!
App promotion
Deku.Deku created the applications with Flutter.If you have interested, please try to download them for free.
