23 skills, in 5 regions.

What your project's words mean, and why old arguments were settled the way they were, written down as the work happens. A new session stops reopening decisions you already made.

You won't remember every skill in a pack this size, and you shouldn't have to. Ask your agent what fits the moment and it names the skill and says why. It points; it never runs anything on its own.

One short interview teaches the pack how your project works: how you test, where the work is tracked, who has the final say. Answer once, and the other skills stop asking.

One model's answer is one opinion. This puts the same question to Claude, Codex, Gemini, and Grok, lets them read each other, and hands you one verdict with the disagreement kept visible. The call is still yours.

For work too foggy to plan in one sitting. The open questions go on a map, with what blocks what, and building waits until nothing the build rests on is still a guess.

Your agent asks you every hard question before the work starts. Vague plans die in the interview instead of in the code.

Every so often, agents walk the whole codebase and report where it has gotten hard to work in. You decide what's worth fixing; nothing gets changed behind your back.

Give it a call recording, a demo video, or a voice memo. You get back what was actually said, with timestamps and stills to prove it. It won't guess at words it can't hear.

Some design questions can't be settled by talking. This builds a quick throwaway version so you can click around and decide. The code is meant to be deleted, not shipped.

An agent goes and reads the actual sources: the vendor docs, the regulation, the upstream code. It comes back with findings you can check, each one pointing at where it was found.

Before anything ships, a team of agents tries to break it, and a skeptic tries to prove them wrong. Only problems that survive both reach you. I can't read the code, so the review has to be this honest.

Before a change ships, this hunts for what it breaks somewhere else: past where grep stops, into library source, timing, and wire formats. Then it proves the one fact the change is safe because of by running real code, not by writing a risk list that merely sounds right.

No bug fix ships until the agent can say what was actually broken, in one plain sentence, with evidence. A patch that just makes the symptom go away gets sent back.

When a session ends, where the work stands goes into one small file. The next session reads it and picks up mid-stride. You stop re-explaining the project every morning.

The agent builds in thin slices that each work end to end, and proves each slice before starting the next. You get checkpoints you can see, not one long silence and a giant pile of code.

One session becomes the manager. It hands work to parallel agents, checks what comes back, and owns fitting the pieces together. It needs a plan that's already decided; it won't decide for you.

While an agent works unattended, it writes down each decision as it makes it: what, why, and a pointer to the proof. You come back and read a table instead of asking for a recap you'd have to take on faith.

Turns a plan you've already settled into tracker tickets a stranger could pick up cold, in the right order. It won't paper over a plan that's still full of holes.

For the steps only you can do: passwords, vendor dashboards, DNS records. Your agent builds a walkthrough that takes you through click by click and checks that each step actually worked.

When your agent's answer doesn't quite make sense, this reads it back in plain sentences and flags which parts are proven and which are just confident.

You can tell when an agent wrote something: the dashes, the padded phrases, the cheerful sign-off nobody asked for. This makes plain writing the default in every message your agent sends, chat replies and commit messages included. It fixes how things sound, and only that.

Instructions for agents fail quietly: read once, skimmed later, then ignored. This is my standard for writing instructions an agent will actually follow, and for cutting the ones it won't.

Agents write pages that read like documentation for other agents. This is my standard for copy a person would keep reading, down to a last scrub for the phrases that give AI writing away.