AGENT SKILL

writing-plans

Create detailed implementation plans for multi-step software work before editing code. Use when requirements or a specification must become concrete file-level tasks, interfaces, acceptance criteria, risks, rollout, or explicitly required validation. Default to no test creation, test modification, test execution, TDD, regression-test, or coverage work unless the user, authoritative specification, or mandatory repository policy explicitly requires testing.

License 许可
MIT
所属仓库
ham-zax/webharness
最近更新
2026-11-15
Stars
★ 0
Forks
0

01 前言 Front Matter

name
writing-plans
description
Create detailed implementation plans for multi-step software work before editing code. Use when requirements or a specification must become concrete file-level tasks, interfaces, acceptance criteria, risks, rollout, or explicitly required validation. Default to no test creation, test modification, test execution, TDD, regression-test, or coverage work unless the user, authoritative specification, or mandatory repository policy explicitly requires testing.

02 资源文件 2

03 SKILL.md 正文

Writing Plans

Create comprehensive implementation plans that an engineer can execute without hidden context.

Use this Skill for planning, not for implementing the plan unless the user has also asked for execution.

Planning principles

  • Preserve the user's explicit requirements and constraints.
  • Inspect the existing repository before inventing file paths, interfaces, or conventions.
  • Follow existing repository patterns unless the plan explicitly calls for changing them.
  • Prefer DRY, YAGNI, clear seams, and small independently reviewable tasks.
  • Keep planning and execution separate when the user asked to plan first.
  • Default to no testing work. Do not add test files, test commands, TDD cycles, regression-test tasks, or coverage work merely because the plan changes executable code.

Test policy

Testing is opt-in for this Skill.

Do not add, modify, or run tests in the plan unless at least one of these is true:

  • the user explicitly asks for testing;
  • the authoritative specification or accepted plan explicitly requires tests; or
  • repository instructions make a specific test command a mandatory completion condition for the requested work.

Do not infer a testing requirement from a bug fix, refactor, public API change, executable behavior, risk level, or the mere existence of a test suite. If testing could be useful but is not required, leave it out of the implementation plan. Mention it only as an optional follow-up when it materially helps the user make a decision.

Scope check

If the work spans independent subsystems, split the plan into coherent phases or subplans. Each major task should produce an independently observable deliverable.

File structure first

Before defining tasks, map the files that will be created or modified and state each file's responsibility.

  • Give each file a clear responsibility.
  • Prefer focused files over large catch-all modules.
  • Keep code that changes together close together.
  • In an existing codebase, respect established structure unless a restructuring decision is part of the requested work.

Task sizing

A task is the smallest unit that carries a coherent implementation change and is meaningful to review independently.

For each task, include:

  • exact files to create or modify;
  • interfaces consumed and produced;
  • implementation steps;
  • expected result or observable success condition;
  • any migration, documentation, compatibility, or rollout work that belongs to that deliverable;
  • only the validation command or check that is explicitly required by the user, specification, or repository contract.

Avoid artificial microsteps that add ceremony without reducing implementation risk.

Plan header

Start plans with:

# [Feature Name] Implementation Plan

**Goal:** [One sentence]

**Architecture:** [Two or three sentences]

**Tech Stack:** [Relevant technologies]

## Global Constraints

- [Exact project-wide constraints copied from the request or spec]

Task template

### Task N: [Component or deliverable]

**Files:**
- Create: `exact/path`
- Modify: `exact/path:relevant-range`

**Interfaces:**
- Consumes: [existing APIs, types, data, or prior-task outputs]
- Produces: [new APIs, types, data, or behavior later tasks depend on]

**Steps:**
- [ ] Implement the smallest coherent change that satisfies the requirement.
- [ ] Inspect the resulting behavior/artifact against the acceptance criteria.
- [ ] Run only validation explicitly required by the user, authoritative specification, or repository contract.

**Acceptance criteria:**
- [Observable result]

Omit the validation step entirely when no validation command or automated check is required.

No placeholders

Do not write vague steps such as:

  • TBD, TODO, implement later, or fill in details;
  • add appropriate error handling;
  • add validation;
  • handle edge cases;
  • similar to Task N.

Replace them with the actual behavior, files, interfaces, cases, and commands required to execute the work.

Self-review

Before presenting the plan, review it yourself without delegating:

  1. Spec coverage: every requirement maps to at least one task or is explicitly marked out of scope.
  2. Placeholder scan: remove vague or deferred instructions.
  3. Type and interface consistency: later tasks use the same names and signatures established earlier.
  4. Dependency order: tasks are ordered so prerequisites exist before dependents.
  5. Test leakage: remove test creation, modification, execution, TDD, coverage, and regression-test steps unless they are explicitly required under the test policy.
  6. Process proportionality: remove setup, validation, or broad commands that do not have a concrete requirement.
  7. Risk check: identify migrations, destructive operations, auth/security concerns, public API changes, or rollout hazards.

Fix issues inline before presenting the plan.

Execution handoff

When the plan is complete, state where it was saved if it was written to the repository. If the user asks to execute it, execute inline in the current session. Do not introduce tests or extra verification checkpoints during execution unless they are explicitly authorized by the test policy. Do not assume sub-agent availability and do not require orchestration.

04 同仓库更多 Skills

ham-zax
ham-zax/webharness

x-content

Create, rewrite, critique, select formats for, discover opportunities for, and learn from X/Twitter content and X Articles for a technical AI-native developer/builder account. Use when turning ideas, source posts, releases, benchmarks, results, conversations, authenticated For You or creator-watch opportunities, or project evidence into an Original, Quote, Thread, Reply, or Article; reviewing article titles/outlines/visual briefs/launch hooks; improving drafts; choosing additive contributions from live X context; or learning from own-account outcomes. Own content intelligence only; compose with agent-browser for live X state and Growth OS for discovery provenance, approvals, measurement, and publication.

★ 0
ham-zax
ham-zax/webharness

systematic-debugging

Root-cause debugging for concrete technical failures including bugs, failing builds or tests, integration issues, performance regressions, and unexpected behavior. Use before proposing or implementing a repair when diagnosis is required. Reproduce the symptom, trace the responsible owner, maintain one leading causal hypothesis, and falsify it with the smallest direct evidence. Compose with Causal Coding for source mutation; testing is opt-in and requires independent authorization.

★ 0
ham-zax
ham-zax/webharness

skill-creator

Guide for creating and updating high-quality skills by translating workflows, conventions, and reusable processes into well-structured skills. Includes context, use case examples and spec for skills. Use this skill whenever a user asks to create, update, edit, improve, package, or troubleshoot a skill, and also for conversational questions about skills in ChatGPT (e.g., "What are skills?", "What can I use skills for?", "What are the best skill use cases for me?", "Where can I find my skills?").

★ 0
ham-zax
ham-zax/webharness

reflexion

Self-refinement, multi-perspective critique, verification, and durable lesson curation adapted from NeoLabHQ Reflexion. Use when the user asks to reflect, self-review, critique, double-check, verify and improve prior work, run a rigorous review, memorize lessons, or says "then reflect" after a coding, analysis, or writing task. Supports repository-aware evidence gathering and works without subagents or Claude hooks.

★ 0
ham-zax
ham-zax/webharness

ponytail

Enforce Ponytail's lazy-senior-developer approach for coding, fixing, refactoring, design, dependency choices, and explicit Ponytail modes such as review, audit, debt, gain, and help. Prefer YAGNI, existing code, standard library, native platform features, existing dependencies, low reader load, and the smallest correct diff. For source mutation, keep Causal Coding authoritative for scope, testing authorization, verification cadence, and stopping. On connected WSL/Linux targets, compose with MCP Harness Router and use `wsl-web-harness` for authoritative repository work.

★ 0
ham-zax
ham-zax/webharness

persistent-agent-loop

Use when one already-defined mission must remain active across extended waiting, repeated tool work, user steering, persistent processes, resumable checkpoints, or recovery after a lost model turn. Preserve mission continuity without treating pending waits, timers, idle periods, or subtask completion as mission completion. Do not use for multi-session decomposition or next-wave planning; use agent-work-planner for that. When implementation-affecting work is involved, preserve Causal Coding authority over mutation, testing, verification, continuation, and stopping. On connected WSL/Linux targets, use mcp-harness-router to select concrete wsl-web-harness wait, Terminal, process, and repository primitives.

★ 0