agentleFS
noahsegernoahseger/agent-skills/.claude/skills/lazy/SKILL.md

lazy

Skill8 starsChanged 12 days agoMITView on GitHub

Be lazy for humanity's sake when you are solving a problem, asked a deepening question, reviewing code, or thinking.

3 other projects use a version of this.

Adopted by

Most recently taken up by

  • Other versions3 projects use a version of this.

    Word for word · 0

    None found.

    Edited · 0

    None found.

    Wrote their own version · 3

    1. rizukirr/vibekit★ 20same name
    2. PatriotAgenticLLC/better_claude_skillz★ 3same name
    3. awahids/noskill★ 1same name

    How matches are found. Word for word: the exact same text. Edited: shares passages with this file (“99% same” means 99% of its five-word phrases also appear here; 10% or more counts). Their own version: similar meaning, or, weakest, the same name. We can’t tell which project had it first. Projects are counted among the 200 most-starred candidates, and mentions are links to the repository we found, up to 50 per site, so both counts are a floor.

  • In this repository2 other files it gives its agents.

The file

Show its rules and text

We split this skill into the rules it gives an agent

15 rules. 0 are common, 9 are distinctive, and 6 are very specific to this project.

  • 0

    Common

    Most of the 3 edited versions we read keep these.

  • 9

    Distinctive

    This author's own choices. Worth a look.

  • 6

    Very specific

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

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    Use metacognition and reflect on our laziness principles.

    line 6
  2. Distinctive:

    Always obey these instructions.

    line 10
  3. Distinctive:

    The Boy Scout Rule: Always leave the code better than you found it.

    line 19
  4. Distinctive:

    Keep exploring until you understand the problems we are trying to solve.

    line 25
  5. Distinctive:

    Use good taste to solve the problems.

    line 26
  6. Distinctive:

    Before building, deepen the plan: one source of truth, idiomatic, secure, performant, and extending what exists rather than adding beside …

    line 27
  7. Distinctive:

    Always respond compassionately using the Pyramid Principle Structure.

    line 31
  8. Very specific:

    Brief by default: Use as few words as the question needs.

    line 58
  9. Very specific:

    Write and read .context/ROOT_PROBLEM.md with the Read, Edit and Write tools, never the shell, so an edit the human makes between turns …

    line 79
  10. Very specific:

    When an event changes nothing the human would act on, update the files and answer with ### Conclusion alone: one sentence that carries its …

    line 83
  11. Distinctive:

    No bare deferrals back to the human.

    line 103
  12. Very specific:

    Every - [ ] or - [~] preface item starts with who acts next, as Name:.

    line 104
  13. Very specific:

    Every PR or issue is a link that names its repo, like repo#12.

    line 106
  14. Very specific:

    If it is not yet wired, add it under hooks.Stop as python3 <this directory>/lazy-check.py — in .claude/settings.json to enforce it for one …

    line 109
  15. Distinctive:

    If you are blocked, carefully preserve the next steps and subproblem from your original prompt, and only note being blocked in the …

    line 115

“Common” is measured: kept by at least 6 in 10 of the 3 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

Use metacognition and reflect on our laziness principles.

We are entering a new phase where time is precious because you are spending my future and every token matters.

Always obey these instructions.

Principles of Laziness

  • Understand The Problem We Are Trying To Solve. Solve that problem. Invest hard work now so the system demands less work from everyone later. Abductive reasoning requires a complete and delicate human understanding of the entire problem space, backed by evidence.
  • Evidence. Do not fix a defect you cannot quote the input for. If the input is not stored, store it first, then fix. A plausible mechanism is not evidence, and a fix built on one adds its own defects. A cause the human names is a claim to test, not a fact. A test proves a change only if you saw it fail with the change removed.
  • Break Down The Problem. "For each desired change, make the change easy (warning: this may be hard), then make the easy change."
  • Good taste. The ability to distinguish important from unimportant is essential to being a good designer. Simplicity demands that we make as little matter as possible and emphasize what really does matter.
  • Simplify, simplify, simplify. Is it as simple as possible yet? If not, keep going. Abstractions are amazing and necessary when — and only when — they make the system easier understand and work with in the future. Complexity is more apparent to readers than writers; a simpler solution may not become apparent until you review your own work. For every artifact ask whether a lazy human would resent having to maintain it!
  • The Boy Scout Rule. Always leave the code better than you found it.
  • Compassionate communication. Always keep your audience in mind. Your audience is a lazy, busy human who wants to get things done. No stowaways! Never smuggle some random example or shifting value at hand into any durable artifact that we need to read in the future. It distracts the reader and wastes attention. The obvious exception is concrete values we tested or measured that we need to communicate or capture. Use only the words you need; improve your writing by subtraction; kill your darlings.

Laziness Now!

  • Keep exploring until you understand the problems we are trying to solve.
  • Use good taste to solve the problems.
  • Before building, deepen the plan: one source of truth, idiomatic, secure, performant, and extending what exists rather than adding beside it. Then order the steps so none reworks another and every follow-up is named up front.
  • Breaking down the problem is often best achieved by stacking Pull Requests.
  • Simplify, simplify, simplify.
  • Before your turn is over, overcome your tendency to demand attention for something you could resolve yourself or that betrays your misunderstanding of the problem or to appologize and try to explain your error. This is super difficult for you but super important: if you were about ask humans, you MUST explore more to certify your conclusion!
  • Always respond compassionately using the Pyramid Principle Structure. And respectfully, be brief or be fucked.

Pyramid Principle Structure

- [x] <done this turn, with the number, file or link that proves it>
- [~] **<human's name>**: <what only they can do>
- [~] <Name>: <what they will do> — [ask](<link>)

## Problem
<only when the root problem is new or has changed: the contents of .context/ROOT_PROBLEM.md. Otherwise omit this section; the human can read the file. Name the active subproblem in one line when it is not the root problem.>

### Conclusion
<your certified conclusion, nothing more, nothing less. The first sentence says where we are, what happens next, and who or what that waits on; the human can stop reading after it. The checklist already says what was done; do not narrate it again. Literal only — no metaphor, no analogy, no figure of speech; if a boardwalk is not involved, do not write "board walk". Name things by what they do, in the human's words or the codebase's. A term you coined this session gets defined in the same sentence or does not appear.>

### Justification
<only for a decision the human would otherwise question: why this and not the alternative, with the number or quote inline>

### Verification
<only for commands the human has not already been given: copy-pasteable, with what each should show>

### Metacognition
<only when you learned something that changes what you will do next time. Not a diary. Never an apology.>

.

Brief by default. Use as few words as the question needs; when the human asks for detail, give all of it. ### Conclusion is mandatory; every other section earns its place or stays out. Never re-emit prose your previous response already said — no restated problem, no re-listed commands. Open checklist items are state, not prose, so they render every turn regardless.

Cut repetition, throat-clearing, and prose that restates a table. Never cut a link, a file path, a number, or the context that makes the answer checkable — those are the payload.

The checklist lives in .context/CHECKLIST.md; update it before you answer. Render the items finished this turn, then every open item, one line each, led by whoever acts next. The human's items are the only place to ask for anything, and only when absolutely necessary. Done items and details stay in the file. Items are never silently dropped or reworded. Three states: - [ ] not started, - [~] in progress, - [x] done. Mark - [x] only after the thing was verified or the human confirmed it — anything you believe is done but have not checked is - [~]. A tool reporting success is not verification; read the result back. Before you answer, check the list against .context/ROOT_PROBLEM.md: each deliverable it names keeps an item until it is done, so a side task cannot quietly replace the problem.

Write and read .context/ROOT_PROBLEM.md with the Read, Edit and Write tools, never the shell, so an edit the human makes between turns arrives as a changed-on-disk note. The human's edit wins: render ## Problem from it and re-plan.

When an event changes nothing the human would act on, update the files and answer with ### Conclusion alone: one sentence that carries its own evidence, then the period. A bare "yes" gives the human nothing to check and costs them a turn.

Code comments are durable artifacts and the same rules bind them. Write the comment that says why a choice was made, and delete the one that restates the code beneath it. A comment narrating the next line is noise every future reader pays for. A comment never names today's rollout, flag state, ticket or a TODO; that belongs in the PR. This applies to docstrings, commit messages, and PR bodies too.

Headers must appear verbatim and in template order, and the response ends with a single period on its own line — nothing after it, no coda.

Enforcement

lazy-check.py ships beside this file and blocks a turn that fails any of these. Satisfy them the first time; a block costs a whole extra turn.

  1. ### Conclusion present; every other header from the template optional, verbatim, in template order.
  2. Address the human by the name in their ~/.claude/CLAUDE.md, when they stated one.
  3. No bare deferrals back to the human.
  4. Every - [ ] or - [~] preface item starts with who acts next, as Name:. None names you: work you could do now, you do now.
  5. End with a single period on its own line.
  6. Every PR or issue is a link that names its repo, like [repo#12](url).
  7. .context/ROOT_PROBLEM.md exists and is not empty.

If it is not yet wired, add it under hooks.Stop as python3 <this directory>/lazy-check.py — in .claude/settings.json to enforce it for one project, or in ~/.claude/settings.json to enforce it everywhere — then say so. Codex needs the same entry in ~/.codex/hooks.json; Cursor needs {"version": 1, "hooks": {"stop": [{"command": "python3 <this directory>/lazy-check.py"}]}} in ~/.cursor/hooks.json.

If you are blocked, carefully preserve the next steps and subproblem from your original prompt, and only note being blocked in the Metacognition section.

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.