agentleFS
jblosseyjblossey/houserules/.claude/skills/planning/SKILL.md

planning

Skill2 starsChanged 21 days agoMITView on GitHub

Use when an approved spec needs its plan: tasks with declared file sets, the tier, critical tasks, technical-debt candidates, and the code-health scan

74 other projects use a version of this.

Adopted by

Most recently taken up by

Used with

Projects with it also use Problem-Solving Techniques, executing and 10 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.
  • truongtv22Skill

    Problem-Solving Techniques

    Apply systematic problem-solving techniques for complexity spirals (simplification cascades), innovation blocks (collision-zone thinking), recurring patterns (meta-pattern recognition), assumption constraints (inversion exercise), scale uncertainty (scale game), and dispatch when stuck. Techniques derived from Microsoft Amplifier project patterns adapted for immediate application.

    Also in 5 projects that use this

  • LucasDuysSkill

    executing

    Autonomous task implementation workflow — implement, test, review, commit for each task in the frontier

    Also in 3 projects that use this

  • mrgoonieSkill

    web-frameworks

    Build modern full-stack web applications with Next.js (App Router, Server Components, RSC, PPR, SSR, SSG, ISR), Turborepo (monorepo management, task pipelines, remote caching, parallel execution), and RemixIcon (3100+ SVG icons in outlined/filled styles). Use when creating React applications, implementing server-side rendering, setting up monorepos with multiple packages, optimizing build performance and caching strategies, adding icon libraries, managing shared dependencies, or working with TypeScript full-stack projects.

    Also in 5 projects that use this

  • mrgoonieSkill

    mcp-management

    Manage Model Context Protocol (MCP) servers - discover, analyze, and execute tools/prompts/resources from configured MCP servers. Use when working with MCP integrations, need to discover available MCP capabilities, filter MCP tools for specific tasks, execute MCP tools programmatically, access MCP prompts/resources, or implement MCP client functionality. Supports intelligent tool selection, multi-server management, and context-efficient capability discovery.

    Also in 5 projects that use this

  • renathoazSkill

    verifying

    Verify work before claiming done.

    Also in 3 projects that use this

  • truongtv22Skill

    mobile-development

    Build modern mobile applications with React Native, Flutter, Swift/SwiftUI, and Kotlin/Jetpack Compose. Covers mobile-first design principles, performance optimization (battery, memory, network), offline-first architecture, platform-specific guidelines (iOS HIG, Material Design), testing strategies, security best practices, accessibility, app store deployment, and mobile development mindset. Use when building mobile apps, implementing mobile UX patterns, optimizing for mobile constraints, or making native vs cross-platform decisions.

    Also in 4 projects that use this

  • +6 more from mrgoonie

The file

We split this skill into the rules it gives an agent

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

  • 0

    Common

    Most of the 66 edited versions we read keep these.

  • 0

    Distinctive

    This author's own choices. Worth a look.

  • 2

    Very specific

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

  • Common
  • Distinctive
  • Very specific
  1. Very specific:

    Read the files that the batch will change (process.code-health-scan).

    line 24
  2. Very specific:

    Write the plan to docs/plans/.

    line 51

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

Planning a batch

You are the controller. A plan turns an approved spec into tasks that an implementer can run without asking you. Plan only from an approved spec; a plan written before its approved spec is void.

Write the output of every houserules command to a file in the batch workspace, a folder of the workspaces location (default .houserules/work/), and read the file with your file-read tool. Treat a << marker or a "more items" note as a lost read and read the source file.

1. Pick the tier and mark the critical tasks

Pick the tier from the change's risk (process.risk-tiers, and the Tiers section of the orchestrating skill). Record the tier and the criterion that selected it in the plan.

Mark each critical task: a task whose change alters the CLI's commands, flags, or output, a schema, authentication or security code, or the data on disk of an install. For a critical task, the plan turns the spec's cases for the task into tests that the implementer commits first, with one recorded run that shows them failing at BASE. The evidence is that run and the whole suite passing at HEAD. The whole-suite half is the integration run of the person who runs the work.

2. Fold in technical debt

Run houserules list --deferred into a file. Fold in every open deferral whose files overlap the planned files of a task and that passes the convenience criterion: folding it in does not turn a non-critical task into a critical task. The plan lists each folded candidate with its overlapping files, and each overlapping deferral that you leave out with the reason.

3. Scan the code health

Read the files that the batch will change (process.code-health-scan). Write a Code health section that names the smells and antipatterns you found, what the plan fixes, and what goes to the tracker and why. A clean scan states what you checked.

4. Write the tasks

Each task names:

  • The work item ids it delivers (Backlog:). The implementer writes a Work-Item: trailer for each id on every commit.
  • Its files: the declared file set, and the interfaces it consumes and produces.
  • The spec sections, tests, and gates it must satisfy, by pointer or verbatim. An implementer who cannot satisfy one flags it.
  • Its steps in test-first order.

A task that adds or tightens a check in check-knowledge, check-backlog, or audit also carries a paper walk: a fresh install, an install on each released kit under the new binary, an install with kept or overridden kit-owned files, and each author class of commits. The report of the task states each accepted red.

Mark tasks parallel only when their declared file sets are disjoint and no task needs another's output (process.parallel-on-disjoint-files). Name the files that you regenerate at integration.

The plan may name a file that two tasks share, such as a command-line entry point whose changes merge by keeping both sides. Two tasks whose only shared file is that file may run at once. You resolve the conflict of the later cherry-pick by keeping both sides and run the gates. Any other resolution is a fix round for the later task.

Order the tasks in waves when some tasks need others. A wave orders the tasks; it is no barrier. A task starts as soon as every task it needs is integrated. A task that consumes only an interface that no open finding changes starts from an interim base that holds the commits of the task it needs. You integrate the commits of the consuming task alone, after the task it needs closes.

A gate command that the harness refuses to an agent is a controller-run integration gate: the plan lists it, and you run it after each integration and record it in the ledger.

Besides the full suite, the plan marks each suite that only you run at integration, for example a slow suite or a suite for another platform. A task's own run skips every such suite.

A task that changes the implementer template, the task-reviewer template, or an eval scenario needs the eval run of the Template evaluation section of the orchestrating skill. Say so in the plan.

5. Approve

Write the plan to docs/plans/. Each factual claim in it about where things live cites the enumeration that found it. Take the plan to the project's owner or decider when they ask for it.

6. Keep the plan true

A decision that makes a sentence of the plan false adds a revision note to the plan in the same turn. At batch close, re-read the declared file set of each task (its Files line) and the plan's Global constraints, when it has them, against the tree. Add a revision note for each sentence that no longer holds.

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.