Chapter 16. Building Skills and Plugins with Coding Agents
- Approved by
- Panaversity ·
In the last four chapters you worked on code with a coding agent. But much of what a team knows is not in its code. It is in how the team does its work.
Take Brightline's accounts payable (AP) team, the people who pay the company's bills. Ana Morales, the AP analyst, knows which checks to run on every new invoice, and that any invoice over $5,000 needs the controller's approval. None of this is written where an AI tool can find it. Some is in Ana's head. Some is in a policy file nobody opens. The rest is in prompts that each person wrote for themselves, each a little different, and one of them out of date.
This chapter fixes that in two steps.
- You write the job down once, as a skill: a short set of instructions, in a folder, that an AI tool reads when it has that job to do.
- You package the team's skills as a plugin: one bundle with a version number that everyone installs, so everyone's AI follows the same instructions.
You will not type these files. Your coding agent writes them, and your part is the part an agent cannot do: deciding what the job is, who owns its rules, and whether the result is right.

Figure 16.1. From know-how scattered in heads and private prompts, to one skill written with its owner, to one plugin the whole team installs.
The point
Write once how your team does a job, as a skill, with the person who owns its rules. Keep every number in tested code. Then release it as a versioned plugin.
After this chapter you can:
- Turn work you keep explaining into a skill your agent loads only when it has that work to do (16.1).
- Decide what goes in the skill and what goes in code or a setting (16.2).
- Build a skill with the person who knows the work, test it, and fix it when it is wrong (16.3).
- Choose who starts each skill, you or the agent (16.4).
- Package skills as a plugin and release it with a version (16.5, 16.6).
- Use one skill in more than one AI tool (16.7).
- See what a plugin did when it ran, and know what that record cannot prove (16.8).
- Decide whether to trust someone else's plugin before you install it (16.9).
How this chapter works
Each lesson teaches one idea and ends with a Try it, ten to fifteen minutes, where your agent does the work and you predict and check the result. All of them use one small practice folder, set up in 16.1, and each one builds on the one before. 16.10 is not a lesson. It is the reference for the steps that differ in Claude Code, Codex and OpenCode, and a Try it links to it when you need one.
The lab comes after the lessons. There you build Brightline's real plugin, the one every later chapter of Part III adds to. Chapters 17 to 20 grow it into a product. Chapter 17 adds a connector of Brightline's own, Chapter 18 adds sign-in, and Chapter 19 adds a database. Chapter 20 gives the connector its own screens and serves these skills from it.
This is a co-build chapter: a domain expert, who knows the work, gives a skill its rules, and a builder makes and packages it. If you are the expert, read this page, 16.1 to 16.6 and 16.9. If you are the builder, read everything and do the lab.
Why it matters
Grace runs month-end close, the work of finishing a month's accounts, at a 30-person accounting firm in Madison, Wisconsin. Over two years, the firm's staff each saved their own copy of a "month-end close" prompt in a notes app. The prompts looked alike, so nobody compared them. One copy was six months old. It still said partners approve payments "over $20,000", from before the firm cut the limit to $10,000.
In March a new hire used that copy. The AI did what it said. A $14,000 invoice was paid without a partner's approval. A criminal had changed that vendor's bank details the week before. The bank recovered part of the money. The firm's insurance company asked one question the partners could not answer: which version of the procedure was the new hire told to use?
Nobody in Grace's story was careless. Three things failed, and each needs its own fix.
- The procedure was kept in a dozen private copies, and nothing said which one was current. Copies like these drift, which means they slowly stop matching. One shared, versioned skill fixes that.
- The limit was a word in a paragraph. Kept in tested code, a test proves it, and one reviewed change moves it.
- Nothing stopped the payment itself. No instruction can do that, however current it is. Only a control where the money moves can.
This chapter builds the first two fixes. Chapter 25 builds the third.

Figure 16.2. Grace's three failures. A skill and tested code fix the first two. Only a control at the action fixes the third.
Brightline's limit will change one day too. On that day, what carries the change into every installed copy, and how would anyone know which version ran? 16.6 answers both.
- Owner
- Panaversity