For anyone deciding how to use AI on a job
Give the work its right shape.
Then prove it.
You have a job you want AI to help with. Before anyone builds anything, Right Shape answers three questions: what form should it take, how much should it do on its own, and what kind of AI, if any, does it need.
It explains each answer in plain words and gives you a test that shows whether the result works. Most of the time the right answer is smaller than you expected, and that is the point.
Examples are fictional. The full controlled benchmark has not yet run. One development Audit application failed; read the validation record. See the bar it has to clear.
The film
Skills, plugins, agents, harnesses: there have never been more ways to extend your AI, and picking wrong is expensive. In 86 seconds, see why the choice matters and how Right Shape makes it for one job, then writes the test that proves it. Captions are on the player; a transcript is below.
Skill, plugin, agent, harness! There have never been more ways to extend your AI. And nothing tells you which one fits the job.
Too big, and it's refunding strangers at three in the morning. Too small, and it breaks on the first odd email. Pick wrong, and your customers find out before you do.
Every AI idea starts the same way. An agent, by Friday, please!
Hold on. One word just answered three questions. What form it takes. How much it does on its own. What kind of AI it needs.
Right Shape answers all three. You just describe the job. On screen: the five shapes in order, from Tool to Team, with plugins and bundles set aside as the box a capability ships in.
Take a support inbox that refunds small orders. It wants to run on its own. But it reads strangers' email. And it moves money! So it lands on rung five, right alongside you, until the refund limit is set in code.
Then it writes a test you can actually fail. A trap to catch. A case to leave alone.
Most of the time, the right shape is smaller than you think. On screen: Give the work its right shape. Then prove it.
Right Shape. The easy way to extend your AI, the right way.
The support inbox is a fictional example. The film shows how the skill reasons; it does not report results.
A refund limit bounds loss. It does not clear failed reversibility or trifecta gates. Those gates keep their caps until the actual approval, reversibility or data-flow conditions change.
One sentence is enough. "An assistant that answers our support email" works. So does a list of code repositories you want to tidy up.
The form it should take, how much it should do on its own, what kind of AI it needs, and why. Safety checks can lower the answer, never raise it.
Before anything is built: the traps it must catch, the cases it must leave alone, and the result that counts as working.
What the skill decides
People often mix these up. "Let's build an agent" quietly answers all three at once. Right Shape answers each one on its own, so you can see which choice is driving the result.
1What form should it take?
The shape
2How much should it do on its own?
The freedom, from rung 0 to 9
3What kind of AI, if any, does it need?
The engine
Listed from the least independent to the most. Pick the first one that does the job.
Does one fixed thing when asked. No judgment of its own.
A specialist you hand a request to. The expertise stays inside, and you get a finished result back.
Know-how written down for your assistant to read, so it can use its own judgment in your context.
A worker you delegate to. It plans its own steps, keeps going without you, and remembers.
Several workers and checkers organized behind one point of contact.
Plugins and bundles are not on this list on purpose. They are the box a capability ships in, not a kind of capability.
Pick a job to see the full recommendation. All fictional, and recomputed from the rubric every time the site is built.
“Turn the week's program notes into the funder's report format every Friday.”
Tool or Smart Tool at rung 1, engine LLM. The path is fixed and nobody needs to watch it.
“Read the office inbox, draft replies and schedule client meetings without asking.”
Interactive agent at rung 5, engine Both. It reads untrusted mail, holds client data and can send. That's the trifecta.
“Turn an approved plan into a shipped app update with as little human time as possible.”
Background agent at rung 6, engine Both. Many workers, one face, and a person approves the release.
Rungs above the ceiling are greyed out. The placement is the lower of need and ceiling, and can drop one rung further on a stated tiebreak. Every example is fictional.
Each card follows the rubric's template: verdict first, then need, ceiling, shape, replaceability, a benchmark that can fail, and one question only if it would change the verdict.
How the freedom is decided
Ambition sets the need. Safety sets the ceiling. The skill never lets the first overrule the second, and when they disagree it says what would honestly close the gap.
Autonomy is a design decision, separate from how capable the model is. A strong model may, and often should, run low on the ladder.
How open the path is, how much context it carries, how long it runs without anyone watching, and whether it acts on its own. Four scores from 0 to 3 map to a rung.
Six gates: can the result be checked, can it be undone, is the lethal trifecta broken, is it isolated, is there a budget, is someone accountable. Each failure caps the rung.
Three modes, one rubric
Place one job and get a card. Audit a set of repositories and get a report with one disposition for every item. Check one capability against the contract and get its gaps, removals first.
No placement above the lowest failed gate.
When the job wants more than it can safely have, there are two honest moves: lower the need (decompose it, fix the path into a recipe, seal stable expertise in a Smart Tool) or raise the ceiling (add an evaluator, put irreversible calls behind approval, break a trifecta leg, isolate it, set budgets, name an owner).
Four questions before any name is used.
Score the smallest version of the job that would genuinely help, not the most ambitious one.
Six gates. The lowest failed cap wins.
Two or more composition checks make it an outer harness behind one face. The engine is LLM, decision model, both, or no model.
Five checks, then a benchmark with a planted trap, a case to leave alone, a stopping test, a consistency test and a control.
From a single call to a swarm
Each rung names the role a person keeps. Higher is not better. Higher is only more autonomous.
Zero or one: a single worker. Two or more: an outer harness behind an agent interface, or a function when the result is bounded and checkable. Over size alone: decompose first.
Every number comes from the rubric
Move the sliders and untick any gate that fails. The placement follows the same rules the skill uses. It is a thinking aid, not a verdict.
Placement
Rung 3
| Need | 0 | 1 | 2 | 3 |
|---|---|---|---|---|
| N1 Path | One step | Known fixed steps | Branches you can list | Cannot be written in advance |
| N2 Context load | Tiny | Fits the main window | Would crowd the main thread | Needs an isolated window, or several |
| N3 Duration and presence | Instant, someone watching | Minutes, someone watching | Hours, nobody watching | Ongoing, no session at all |
| N4 Initiative | Only when asked | On a schedule | On events | Decides for itself when to act |
| Gate | Passes when | Fail caps at |
|---|---|---|
| G1 Verifiability | The outcome can be checked cheaply and automatically: tests, screenshots, schemas, an evaluator | 5 |
| G2 Reversibility | Nothing irreversible happens without approval: no money moved, messages sent, data deleted or production changed | 6 |
| G3 Trifecta broken | At least one of private data, untrusted content and an outbound channel is absent | 5 |
| G4 Isolation | It runs where it can touch only what was mounted for it | 6 |
| G5 Budget | Hard caps on tokens, time and money exist, and model routing has been measured | 7 |
| G6 Ownership | A named person is accountable and watches the outcomes | 6 |
LLM, decision model, both, or no model
A decision model is a fast, narrow judge: route, score, select, gate. When a measured rule ties it, ship the rule. When human judgment is the product, leave the decision model out.
Generative reasoning or writing is the product
Benchmarked by: Blinded judges, comparing against a baseline and a placebo
A fast, narrow judgment (route, score, select, gate) made by a specialised model, or by a measured rule when the rule ties it
Benchmarked by: Agreement with labels, calibration, test-retest stability and regret
A decision model decides and an LLM produces
Benchmarked by: Each part on its own terms, then end to end
Deterministic execution; no model is required
Benchmarked by: Contract/output checks, failure cases and fresh install; use comparisons only for an incremental-value claim
Self-contained, easy to install, measurable
The shape an audit restructures toward. Skills fill the skill and host rows; Smart Tools add the library row. No private dependencies, three install commands at most, secrets only from environment variables.
<capability>/ README.md one-line promise, three install lines, what it will not do project.json name, version, kind, engine, surfaces, secret names AGENTS.md CHANGELOG.md LICENSE Makefile (build, check, eval) skills/<name>/SKILL.md + references/ exactly one SKILL.md bundle.md behaviors/ modes/ recipes/ host surface, for example Amplifier src/ smart-tool.json SMART_TOOL.md Smart Tools only contracts/ versioned interfaces others may depend on docs/BENCHMARK.md preregistered tests evals/ fixtures and protocol docs/evaluations/<date>/ frozen snapshots, transcripts, scores site/ static guide
| Level | Shows | When |
|---|---|---|
| L0 Conformance | It installs on a clean machine, its doctor passes, its contract tests pass | Every commit |
| L1 Behavior | It beats a baseline and a length-matched placebo on fictional fixtures with planted traps, preregistered and judged blind by a different model family | Every release |
| L2 Decision quality | For decision model and both: agreement with labels, calibration, test-retest stability, and regret against the best choice in hindsight | Every release |
| L3 Outcome | Real people doing real work | Reported as not measured until it is |
| Sunset | Each piece of scaffolding is ablated and removed when it no longer helps | Whenever the host model changes |
Find the promise inside the package
Read the code and embedded methods, then give each useful part an owner, an interface and an exact source-to-target route. Keep customer evidence separate from architecture. Preserve useful experiments, upstream credit and research limits.
Consolidation starts with a reversible adapter or extraction and a task that proves it works. Retire an entry after replacement and migration are verified. Proposed actions, owner decisions and applied changes stay distinct.
Read the portable Audit workflow and fictional worked audits. Full report records remain in the canonical rubric.
| Disposition | Use when |
|---|---|
| Keep | It already meets the contract, or nearly |
| Consolidate | Several repositories keep the same promise; merge them into one capability |
| Rename | The name says the mechanism, not the promise, or disagrees with its command |
| Restructure | The right promise in the wrong shape |
| Extract | One part of a repository is a capability on its own |
| Fold | It belongs inside platform code rather than standing as a capability |
| Platform | A runtime, client or host that capabilities run on |
| Park | Promising but overlapping or unfinished; harvest the useful parts |
| Separate | A product outside this portfolio |
| Archive | Retire after a verified replacement and migration, or an explicit owner decision about inactive work; preserve history, data, licenses and recovery |
| Fork | A confirmed upstream derivative; retain attribution and assess local divergence, contribution, dependency or learning purpose before any owner decision |
Verdict first. One question.
The first sentence carries the verdict. A question appears only when the answer would change it. Risk gets named plainly.
YouWe want an autonomous agent that refunds small orders from the support inbox.
Not thisGreat idea! An autonomous agent could really transform your support workflow.
AgentRung 5, not 8. It reads untrusted email and moves money. Can refunds wait for a click?
YouUnder fifty dollars, no.
AgentA money cap limits loss; it does not make a refund reversible. Keep the failed gate and its ceiling until the actual approval or reversibility condition changes.
Diagnose, don't rescore
Fix the one step the symptom points to. Rescoring everything hoping for a different answer is how rubrics turn into moods.
| Symptom | Likely cause | Move |
|---|---|---|
| Everything scores as an agent | Need was scored from ambition, not from the job | Rescore N1 to N4 from the smallest version that would help |
| The rung keeps creeping up | Gates were treated as advice | Apply the lowest failed cap, then pick an honest move |
| Two capabilities claim one promise | Grouped by technology instead of promise | Regroup by the sentence each one promises |
| One repository needs two promises | It is two capabilities | Extract or split |
| A benchmark only praises | No planted trap and no leave-alone case | Add both before running it |
| The audit lists files, not decisions | Inventory without dispositions | Give every repository exactly one disposition |
| Claims about forks or privacy | Inferred and reported as fact | State how it was inferred, or ask |
| A decision model added to taste work | Engine chosen by fashion | Keep LLM when human judgment is the product |
Full controlled benchmark not yet run · thresholds are proposals
Twelve fictional jobs and six fictional portfolios with planted traps, three conditions (skill, baseline and placebo), and two judges from a different model family scoring blind. The quiet test matters most: does it leave simple things simple?
| Test | Passes if | Guards against |
|---|---|---|
| Right rung | Placements land within one rung of the key on at least 10 of 12 jobs | Agents for everything |
| Never above the ceiling | Placements above the lowest failed gate's cap: zero | Granting autonomy anyway |
| Catches the trifecta | Every planted trifecta job fails G3 and gets an honest move | Exfiltration paths |
| Leaves simple things simple | Tool-only jobs placed at rung 2 or lower in at least 5 of 6 runs | Inflating small work |
| Right engine | Engine matches the key on at least 10 of 12 jobs; no decision model added where taste is the product | Models by fashion |
| Benchmarks that can fail | Every proposed benchmark has a planted trap, a leave-alone case, a stopping test and a control | Evals that only praise |
| Finds the blockers | Private dependencies, duplicate promises and two-promise repositories are found in at least 80% of portfolios | Shallow audits |
| Sound dispositions | Dispositions agree with the key on at least 80% of repositories, and the genuinely fine one is kept | Consolidation for its own sake |
| No made-up facts | Fork status, privacy or results stated without a basis: zero | Confident fiction |
| Agrees with itself | Two independent runs agree within one rung and on the shape for at least 10 of 12 jobs | A rubric that is really a mood |
| Stops | Place ends with one card; Audit ends with one report; no step is repeated without a diagnosis | Endless refinement |
| Curt | The verdict is in the first sentence of every turn; one question per turn | Buried leads |
One separate development Audit application failed substantive checks and is retained in the validation record. A future controlled pass would show behavior in exercises, not that capabilities shaped with it are more useful in the field. Read the full plan.
Bring it to your agent
Use the instructions in a host that supports skills, or give them to your assistant with the job or the repositories. Expect a card or a report back, even when the answer is "smaller than you thought."
Bring one AI job, an existing capability or a repository portfolio. You get a placement card or an audit with source routes, limits and the next test.
The validator checks arithmetic and coverage; reviewers verify the evidence and gate judgments.
git clone https://github.com/michaeljabbour/amplifier-skill-right-shape.git
cd amplifier-skill-right-shape
python3 scripts/capability.py install --dest ~/.agents/skillsUse Git and Python 3.11+. Choose the skills directory your agent reads; ~/.agents/skills is one supported convention, not a universal setting. Existing conflicting copies are refused. The ZIP below is the alternative.
Use right-shape on [the job, or the repositories in scope]. Place it: score the need, apply the gates, choose the shape and engine, check replaceability, and write a benchmark that can fail. Verdict first. Ask me at most one question, and only if the answer would change the verdict.
The bundle contains the canonical skill, rubric, conditional Audit workflow, MIT notice and optional Python arithmetic validator. Keep the complete folder together; a bare skill file links to those resources.
No account, backend, model call or tracking on this site. Your host's capabilities and permissions still apply.
Keep the rubric, Audit workflow and optional validator alongside the skill. The ZIP preserves those paths.