The third time the AI shipped a mobile screen with desktop typescale and desktop components, I let out a big sigh and thought, “is it me?” Wrong hierarchy, wrong touch targets, a layout built for a mouse on a device with no mouse. Time spent writing long, detailed corrective prompts, sometimes going into the code myself to fix it by hand, and I wasn’t getting anywhere. I was correcting the same mistake, not building anything new.

That was the moment I stopped treating this as a prompting problem and started treating it as a memory problem.

Before skills: writing the same instructions, again and again

If you’re new to AI coding agents, here’s the pattern most people fall into. You describe what you want, in detail, every single time: use this typescale, sentence case only, error messages follow this pattern, this is a mobile device so designed for a thumb, not a mouse. The AI does a decent job. Then, in your next session, or even your next prompt, it forgets all of it and drifts back to its defaults. So you write the same paragraph again. And again.

It’s not that the AI is bad at work. It’s that it has no memory of your standards unless you carry them into every conversation yourself.

An agent skill is the fix for that. Think of it like the difference between handing a new team member an onboarding pack they read once and forget, and pinning a pilot’s checklist directly to the dashboard before every single takeoff. A skill is a written rulebook that lives inside the project itself. The AI checks it before it acts, not because you reminded it this time, but because the rule is permanently pinned to the project. You stop repeating yourself. The standard stops depending on your memory, or the AI’s.

That’s the whole idea. Everything below is what it looks like when you actually build a set of them for real, high-stakes work.

Building the rulebook: five domains of judgement

I was building a prototype for a GOV.UK service. It had to meet GOV.UK design standards, WCAG accessibility requirements, and the service manual rigour around why decisions were made, not just what the decisions were.

That’s a lot of standards to hold in your head, and even more to repeat to an AI agent every time you ask it to build a new screen. So instead of re-explaining the same rules turn after turn, I wrote them down once as skills:

Skill What it holds the line on
Design Layout, typescale, and content guidelines for a mobile-first government-standard interface, so no more desktop components creeping into a mobile app
Accessibility WCAG 2.2 AA checks run as a precondition before anything ships, not an afterthought. The whole process shifted left rather than catching things after releases.
Decisions Every deliberate departure from standard practice gets logged with a reason, so exceptions are visible, not silent

There were more skills underneath these (routing, release management) handling the technical plumbing, but these three are the ones doing the judgement work, the ones that used to cost me hours of manual correction.

The typescale problem that started all this? Solved the moment the design skill existed. The AI now checks mobile layout rules against a written standard before it writes a line of code, instead of guessing and waiting for me to notice.

None 
---
name: design
description: Combines visual layout structure (optimised for mobile)
and GOV.UK content guidelines.
---

# GOV.UK Design Rules
1. **Sentence Case**: Use sentence case for all titles, headings, form labels, and buttons ("Check your answers", NOT "Check Your Answers").
2. **Touch Targets**: Always use standard Nunjucks macros (`govukInput`, `govukRadios`). Never override default GDS heights with custom CSS.
3. **Mandatory Checkpoint**: Stop and present proposed layout and copy to the user for explicit confirmation before writing any code.
A snippet from a skill
None 
Using the /design skill, help me create a multi-choice question page for selecting document types.
How I would call or use the skill to create build new screens

The system that grew, then got smaller

Here’s the part I didn’t expect. I didn’t build this in one clean pass. I started with seven separate skills, splitting things like mobile layout and content guidelines into their own files because they felt like different disciplines.

They weren’t. You can’t design the layout without simultaneously deciding the label text, the hint text, the error message. They’re one decision, not two. While there is a single context, having the skills split across two files created complexity for the model deciding which skills to apply, and I was doing more coordinating between skills than the skills were saving me.

So I merged them. Seven skills became five. Layout and content became one design skill. Release publishing absorbed the housekeeping tasks that used to be separate steps. What was left was sharper: each skill mapped to one real discipline, not one convenient file boundary.

If you’re building your own skill set, this is the lesson I’d pass on before you start: don’t over-split. A skill should match a domain of judgement, not a folder structure that seemed tidy on day one. You’ll probably get the split wrong the first time. That’s fine. Consolidating later is a sign the system is working, not that you failed to plan it properly.

A skill should match a domain of judgement, not a folder structure

The AI executes. I still decide.

None of this makes the AI the decision-maker. It makes the AI a much better-briefed executor, one that doesn’t need the brief repeated.

Every design action still has a checkpoint where the AI shows me its proposed layout and copy before it writes any code, so I approve the direction before it’s built, not after. When a screen genuinely needs to break from standard practice, the AI can’t just quietly do it. It has to log why, in my own words, so the exception is visible and accountable rather than buried in a commit message six weeks later. And nothing ships without me manually triggering the release step myself, accessibility audit included.

The skills didn’t remove me from the process. They removed the part of the process that was just me repeating myself. What’s left is the part that actually needed a human: judgement, approval, accountability. That’s the time I got back, and it’s the time I’d rather spend solving other problems than correcting.

How does this fit into the bigger picture? 

Agent skills can be the active building blocks of a larger, living project memory. In practice, skills can compose and call each other automatically, ensuring that day-to-day execution continuously updates the project brain without extra manual effort.

To explore how these individual skills combine to form a robust, queryable shared memory that prevents project amnesia across team handovers, read our companion blog from Mike Tattersall.

Discover more