agentleFS
ric03uecric03uec/clawrium/.claude/skills/itx-plan-scaffold/SKILL.md

itx-plan-scaffold

Skill67 starsChanged 2 months agoApache-2.0View on GitHub

Create phased execution plan with entry/exit criteria

The file

We split this skill into the rules it gives an agent

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

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈5

    Distinctive · estimate

    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:

    Create a phased execution plan from a plan-create output, defining entry/exit criteria for each phase.

    line 9
  2. Distinctive:

    Multi-phase: Create subtasks, execute in order

    line 27
  3. Distinctive:

    Post Scaffolding: Add as comment on issue

    line 53
  4. Distinctive:

    Use entry/exit criteria to enable parallel execution of independent phases

    line 135
  5. Distinctive:

    Prefer more smaller phases over fewer larger ones

    line 136

≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “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

Execution Scaffolding

Create a phased execution plan from a plan-create output, defining entry/exit criteria for each phase.

Instructions

  1. Fetch Issue: Get full issue details with existing plan
    gh issue view <number> --json number,title,body,labels,comments
  2. Read Plan: Find the plan-create comment from issue comments or read from .itx/<number>/00_PLAN.md
  3. Analyze Complexity:
    • Simple (< 3 files, single concern): Single-phase execution
    • Moderate (3-8 files, related changes): 2-3 phases
    • Complex (8+ files, multiple concerns): Multi-phase with subtasks
  4. Decide Execution Mode:
    • Single-phase: Direct to /itx-execute
    • Multi-phase: Create subtasks, execute in order
  5. Create Scaffolding: For each phase, define:
    ### Phase N: <Name>
    
    **Entry Criteria** (must be true to start):
    - <condition>
    
    **Exit Criteria** (must be true to complete):
    - <test passing>
    - <validation rule>
    
    **Dependencies**: Phase <N-1> (or "None" for first phase)
    
    **Files Affected**:
    - `path/to/file.ext` - <change type>
    
    **Complexity**: simple/moderate/complex
  6. Save Scaffolding to File:
    # Write scaffolding to .itx/<number>/01_EXECUTION.md
  7. Post Scaffolding: Add as comment on issue

    ## Execution Scaffolding
    
    **Mode**: single-phase | multi-phase (<N> phases)
    
    <phase definitions>
    
    ---
    
    <details>
    <summary>Prompt Log</summary>
    
    **Stage**: scaffolding
    **Skill**: /itx-plan-scaffold
    **Timestamp**: <ISO timestamp>
    **Model**: <model>
    
    ```prompt
    <original user prompt>
    </details> ```
  8. Create Subtasks (if multi-phase) and link as sub-issues:
    # Extract repository info
    REMOTE_URL=$(git config --get remote.origin.url)
    OWNER_REPO=$(echo "$REMOTE_URL" | sed -E 's/.*[:/]([^/]+\/[^/]+)(\.git)?$/\1/')
    OWNER=$(echo "$OWNER_REPO" | cut -d'/' -f1)
    REPO=$(echo "$OWNER_REPO" | cut -d'/' -f2)
    
    # Create subtask
    CHILD_URL=$(gh issue create \
      --title "[Parent #<parent>] Phase N: <name>" \
      --label "ready" \
      --body "<phase details>")
    CHILD_NUM=$(basename $CHILD_URL)
    
    # Link as sub-issue using GraphQL with dynamic repo
    gh api graphql -f query='
      mutation($parentId: ID!, $childId: ID!) {
        addSubIssue(input: {issueId: $parentId, subIssueId: $childId}) {
          issue { number }
          subIssue { number }
        }
      }' \
      -f parentId=$(gh api graphql -f query='query($owner: String!, $repo: String!, $issue: Int!) { repository(owner: $owner, name: $repo) { issue(number: $issue) { id } } }' -f owner="$OWNER" -f repo="$REPO" -F issue=$PARENT_NUM | jq -r '.data.repository.issue.id') \
      -f childId=$(gh api graphql -f query='query($owner: String!, $repo: String!, $issue: Int!) { repository(owner: $owner, name: $repo) { issue(number: $issue) { id } } }' -f owner="$OWNER" -f repo="$REPO" -F issue=$CHILD_NUM | jq -r '.data.repository.issue.id')
  9. Update Labels:
    gh issue edit <number> --remove-label "planned" --add-label "ready"

Phase Guidelines

Entry Criteria Patterns

  • Prerequisite phase complete
  • Environment prepared (dependencies, config)
  • Data/fixtures available
  • Branch created

Exit Criteria Patterns

  • All tests passing
  • Lint/typecheck clean
  • Manual verification checklist
  • Documentation updated
  • No regressions introduced

Ordering Rules

  1. Foundation phases first (schemas, models)
  2. Core logic second (services, business rules)
  3. Integration third (APIs, handlers)
  4. Presentation last (UI, docs)

Notes

  • Each phase should be independently verifiable
  • Exit criteria of phase N = entry criteria of phase N+1
  • Use entry/exit criteria to enable parallel execution of independent phases
  • Prefer more smaller phases over fewer larger ones
  • Execution plan saved to .itx/<N>/01_EXECUTION.md for reference

Prompt Logging

REQUIRED: Append prompt log to .itx/<N>/01_EXECUTION.md.

See AGENTS.md for format specification.

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.