agentleFS
lithammerlithammer/ai/skills/shape/SKILL.md

shape

Skill0 starsChanged 56 days agoMITView on GitHub

Review a working change for its shape (cause, ownership, states, names, size, reuse, cost), then apply what you accept.

39 other projects use a version of this.

Adopted by

Most recently taken up by

Used with

Projects with it also use layout, explore and 9 more.

Other files people use alongside this one.

Files found in the same public projects as a version of this one, more often than they turn up anywhere else. Each project counts once, large collections count for less, and this file's own repository is left out.
  • owshq-mecSkill

    layout

    Improve layout, spacing, and visual rhythm. Fixes monotonous grids, inconsistent spacing, and weak visual hierarchy. Use when the user mentions layout feeling off, spacing issues, visual hierarchy, crowded UI, alignment problems, or wanting better composition.

    Also in 8 projects that use this

  • genomewalkerSkill

    explore

    RLM-style recursive memory exploration - dynamically navigate the memory graph

    Also in 3 projects that use this

  • Microsoft AzureSkill

    build

    Build the TypeSpec Rust emitter from source. Run this after cloning the repo, after pulling changes, or when TypeScript source files have been modified.

    Also in 6 projects that use this

  • MicrosoftSkill

    help

    Entry point for the MedImageInsight plugin, covering the getting-started walkthrough, how the skills work, what MI2 is, and troubleshooting.

    Also in 3 projects that use this

  • AnthropicSkill

    brief

    Generate contextual briefings for legal work — daily summary, topic research, or incident response. Use when starting your day and need a scan of legal-relevant items across email, calendar, and contracts, when researching a specific legal question across internal sources, or when a developing situation (data breach, litigation threat, regulatory inquiry) needs rapid context.

    Also in 3 projects that use this

  • dubwoahSkill

    ask

    Answer questions about the codebase without generating or modifying any code. Use when the user wants to understand how something works, find where something is defined, or explore the project structure. Invoked with /ask.

    Also in 3 projects that use this

The file

We split this skill into the rules it gives an agent

3 rules. 0 are common, 3 are distinctive, and 0 are very specific to this project.

  • 0

    Common

    Most of the 37 edited versions we read keep these.

  • 3

    Distinctive

    This author's own choices. Worth a look.

  • 0

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    If it reports findings, present each with its counter-draft, its cost, and your recommendation with its reason, and wait for the person to …

    line 16
  2. Distinctive:

    Add nothing of your own reading.

    line 30
  3. Distinctive:

    Do names, types, and comments say less than the code knows?

    line 80

“Common” is measured: kept by at least 6 in 10 of the 37 edited versions of this file we could read. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Shape

Run

  1. Diff the review target: the current branch against its merge-base with the default branch, plus uncommitted changes, unless the invocation names another target.
  2. Spawn one reviewer for both Where axes and wait for it.
  3. If it reports findings, present each with its counter-draft, its cost, and your recommendation with its reason, and wait for the person to accept or decline it. Apply the accepted ones.
  4. Spawn one reviewer per How axis, in parallel, on the code as it now stands, and give each the Where findings with the person's ruling on each.
  5. Apply each How finding whose counter-draft stays inside the diff, preserves behavior, and leaves every test in place.
  6. End with the findings by axis and which you applied, one combined counter-draft for the rest, and the decisions they leave the person, each with your recommendation.

Give every reviewer the Scope, Evidence, and Report sections and its own axis sections, copied verbatim, plus the review target and the ticket. Add nothing of your own reading.

Scope

Review the axes your task names. Other reviewers cover the other axes, and a correctness review runs on the result. When your task carries Where findings, a person has ruled on them; leave them out.

Evidence

For each candidate, write the counter-draft: the code that should exist, not the smallest diff from the old shape, and no more complex than the problem needs. A finding is the gap between the diff and that draft, and the draft is its evidence. Show that the draft preserves behavior against callers and tests, and name the concrete cost of the gap: what a maintainer must hold in mind, keep in sync, or work around. Line count alone is not a cost.

Where

Root cause

Does the change fix the mechanism that produces the problem, or apply a band-aid downstream of it? A special case layered on shared code is the usual sign. Trace the problem to its cause and name the change there, even where the ticket planned another approach: a ticket's plan is a first sketch, written before anyone dug in.

Ownership

Does each responsibility the change adds or moves live in the module that owns its data and rules? Find information leakage: knowledge of one module's rules or internals spread into its callers. Verify the owner against interfaces and callers, and keep the search tied to the changed responsibility.

How

States

Does the code admit states the problem does not have? Find data shaped to hold combinations the problem never produces or to store what could be derived, and checks that guard states callers and types already rule out. Make illegal states unrepresentable, and parse, don't validate: input is checked once where it crosses a trust boundary, into a type the rest of the code can trust. Show the reshaped data, or the proof from callers and types, and the code it deletes.

Precision

Do names, types, and comments say less than the code knows? Name the precise replacement, in the ubiquitous language. When a comment explains what a name could say, the name is the finding. When the code relies on a constraint no name or type can show, the missing comment is the finding.

Proportion

Does the change carry accidental complexity: concepts its problem does not need? A concept is anything a reader must hold in mind. Code the change repeats or leaves dead counts; so does compatibility with anything the base never shipped, and a comment that restates the code or recounts how the change came about. Name each concept the counter-draft removes.

Reuse

Does something already do this, in the repository or in what it already depends on? Name the existing symbol, check that its behavior and dependency boundaries fit this caller, and weigh the reuse against the cost of changing the caller.

Efficiency

Does the change add work the result does not need, or put work where it costs more: on a hot path, at startup, in sequence where it could run concurrently, or in memory held longer than its use? Name the cheaper alternative. Calibrate to where the code runs; work off the hot path costs little.

Report

Return each finding with its file and line, its axis, the counter-draft, the cost, and whether the draft reaches outside the diff.

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.