Runs natively onClaude CodeCodex
Skills For Real Non-Engineers
I've led dev teams for over twenty years. I never wrote the code. These skills give me a lead developer who runs the team, so all I have to bring is the idea. Four shipped products so far.
Most of these skills started as someone else's. Fifteen are adapted from Matt Pocock's Skills For Real Engineers, three from Lauren Tan, five are mine. I rewrote nearly all of them for someone who won't read the code, then tied them together under one orchestrator session that takes the idea, decides what gets grilled, mapped, prototyped, built, and reviewed, and runs the rest. That's what lets a non-engineer ship at production quality. I talk to that one session the way I've always talked to a dev lead.
Point at a skill to trace what feeds it and what it feeds.
Thirty seconds to install
Claude Code
$ /plugin marketplace add timharris707/skills$ /plugin install team-workflow@skills # the pack, start hereCodex desktop, adapted for Astra workflows
$ codex plugin marketplace add timharris707/skills$ codex plugin add clickai-codex@clickaiThat's the install. Open a session in a real repo and you can ask for any skill by name. Both editions cover all 23 skills, with instructions adapted to each app. The Codex edition keeps task ownership through compaction and respects your model settings. Standalone skills and other runtimes: every install option →
Start with the seat, not the list
Install the pack, run setup once, then open one session and say “orchestration mode.” That session is your lead. It reads the map, routes the work to the other skills, and comes back to you only for decisions. Setup asks whether you'll read the code your agents write or lead from outside it; answer lead, and every new session in that repo opens in the seat. The chart above is what your lead has to work with.
What these fix
Stop re-explaining your workflow every session
You finally got a session working the way you work. It knew the plan, the standards, the things it must never touch. Then it ended, and this morning's agent knows none of it. Every skill here is a workflow I got tired of re-teaching, written down once, so any agent can pick it up by name. Four failures cost me the most, and the fix was never a smarter model. It is a written procedure the agent cannot skip.
“It built the wrong thing, confidently.”
You described the feature, the agent agreed instantly, and hours later you are reviewing a polished implementation of something you never meant. Nobody pressure-tested the plan, so the agent filled every gap with a guess, and the cost lands at review time, the most expensive place to find out. grilling inverts the ritual: the agent interviews you, round after round, and it is done when no question on the table is still open and the settled decisions are written down. It will not make the calls for you. You decide everything; it just refuses to let a question slide by unanswered.
“One model's opinion.”
An architecture, a migration, a contract: a hard call, decided by whichever model you happened to ask, in one pass, with nobody pushing back. When that call is wrong, you rebuild. advisory-board convenes Claude, Codex, Gemini, and Grok on the same material, has them answer independently and then read each other, and is done when you hold one verdict with the dissent preserved and a list of what the board could not verify. The board never edits your files, and it is still models arguing with models. The final call stays yours.
“The session died and took the state with it.”
Yesterday's session knew the plan, the constraints, and the half-finished thread. Then it hit its limit, and today's opens blank, so you spend the start of every session rebuilding the end of the last one. handoff is done when one small file lets a fresh session resume mid-stride with nothing re-explained, and domain-memory keeps the permanent layer: what your repo's words mean, and why its settled decisions went the way they did. A handoff is a pointer, not a transcript. It records where things stand and where the durable records live, never the whole conversation.
“You're the bottleneck between five agents.”
Parallel agents sound like leverage until every one of them needs context only you hold, and the work moves at the speed of your typing. to-tickets turns a decided plan into tracker items a stranger could pick up cold, blocking edges included, and orchestrate is done when your session plays the lead: it assigns, audits, and merges instead of implementing. Neither will untangle an undecided mess: they need a plan already settled and a tracker to put it on.
Start here
Your first week
- Point the pack at one real repo. Run the install above, then tell a session in that repo to run setup. It is a short interview, once per repo: how you test, where work is tracked, who has the final say, and whether you read the code or lead from outside it. It records; it never restructures what you already have. You will notice every later skill stops asking you those questions.
- Grill your next real plan. Pick something you were going to build anyway and run grilling on it first. It works only as hard as your answers, so bring real attention. You will notice a question you cannot answer cleanly — that question was headed for the codebase.
- Close with handoff, then open a fresh session. It reads one small file and resumes mid-stride; deep history stays in the records that file points to. This is where the catalog earns its keep: the re-explaining just stops.
- When a call is worth real money, convene advisory-board. Four vendors' frontier models on one question beats one model's first answer. Expect it to take longer than asking once. Deliberation is the point.
- For the rest, ask router. It names every skill in the pack and when to reach for each. It is a map, not a manager — it points, you invoke.
The catalog
All 23 skills
The full reference: 23 skills in 5 regions, MIT licensed, each one a self-contained SKILL.md any agent can read plus the templates and scripts it needs. The chart at the top of the page plots how they hand work to each other; the vocabulary it speaks — fixes, bearings, lanes — is defined in the legend.
Orient
Bind the discipline to a repo, and find your way around it.
3 skills- domain-memorypackfires itself
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.
- routerpackfires itself
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.
- setuppackfires itself
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.
Decide
Settle what is still open before anyone writes a line of it.
3 skills- advisory-boardstandalonefires itself
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.
- decision-mappackfires itself
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.
- grillingpackfires itself
Your agent asks you every hard question before the work starts. Vague plans die in the interview instead of in the code.
Investigate
Answer what discussion cannot — from sources, or from running code.
4 skills- codebase-reviewpackfires itself
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.
- ingeststandalonefires itself
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.
- prototypepackfires itself
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.
- researchpackfires itself
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.
Run
Get decided work onto the board, through the lanes, and handed on.
9 skills- adversarial-reviewpackfires itself
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.
- blast-radiusstandalonefires itself
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.
- diagnosepackfires itself
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.
- handoffpackfires itself
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.
- implementpackfires itself
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.
- orchestratepackfires itself
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.
- show-me-your-workpackfires itself
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.
- to-ticketspackfires itself
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.
- wizardpackfires itself
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.
Author
Standards for writing — documents agents consume, and pages humans read.
4 skills- huhstandalonefires itself
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.
- plainspokenstandalonefires itself
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.
- writing-for-agentsstandalonefires itself
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.
- writing-for-humansstandalonefires itself
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.
The maker
Tim Harris
I never wrote the code. I lead the team that does.
The product calls and the standard are mine. The typing is theirs. ModelDeck, Panely and HiveRunner were all built that way, and so was this catalog — every skill here started as a workflow I got tired of re-explaining at the top of every session.
This page has a twin written for agents. Append .md to any skill URL, or start at llms.txt, and you are reading exactly what my agents read.