ha-coding-plan

Generates evidence-based implementation plans for non-trivial code changes across multiple languages.

1.6k|149|Updated Mar 13, 2026
One-click install
npx skills add https://github.com/shiwenwen/hope-agent --skill ha-coding-plan
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: ha-coding-plan
Source: https://github.com/shiwenwen/hope-agent/tree/main/skills/ha-coding-plan
Command: npx skills add https://github.com/shiwenwen/hope-agent --skill ha-coding-plan

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Non-trivial code changes often fail because they start without a grounded plan: dependencies get ordered wrong, risky migrations lack rollback paths, and completion criteria go unverified. This Skill turns vague feature requests into concrete implementation maps rooted in actual repository evidence.

Core Features & Use Cases

  • Evidence-First Planning: Reads AGENTS.md, architecture docs, current diffs, and critical code before proposing anything, so plans never invent files, APIs, or migrations.
  • Structured Plan Contents: Each step names outcomes, critical files, dependency ordering, data/compatibility/concurrency risks, and direct verification signals.
  • Mode-Aware Execution: Stays read-only in Plan Mode, but continues implementation automatically outside it when the next step is clear, and coordinates with goal tracking and multi-agent execution skills.
  • Use Case: Ask it to plan a cross-crate feature touching Rust and TypeScript code; it traces the owning code paths, orders the dependent steps, flags migration risks, defines verification for each criterion, then proceeds to implement.

Quick Start

Ask the agent to plan this cross-crate feature with rollback and verification steps, then implement it.

Frequently Asked Questions about ha-coding-plan

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I plan a complex code change before implementing it?

Describe the change and its completion criteria, and the skill reads your repository evidence first, then produces an ordered implementation plan naming critical files, dependencies, risks, and verification steps. Outside Plan Mode it can continue into implementation automatically.

When should I write a formal implementation plan versus just coding?

Use a formal plan when work crosses ownership boundaries, involves schema or migration risk, has ambiguous architecture, or needs parallel isolation. Skip it for small, obvious, reversible edits with a direct check.

Does the planning skill support languages beyond Rust and TypeScript?

Yes, it applies to Python, Go, Java, Kotlin, Swift, C, C++, Ruby, PHP, and shell files among others. The planning methodology is language-agnostic and grounded in reading the actual repository code.

Can the plan handle database migrations with rollback?

Yes, migration and recovery risk is an explicit planning trigger. Each plan step must name data, compatibility, and rollback risks plus a direct verification signal, so read-only migration plans with rollback paths are a supported scenario.

What are the limitations of AI-generated implementation plans?

Plans are only as good as the evidence gathered, so the skill forbids inventing files, APIs, or tests from naming alone. Steps are marked parallel only when truly independent with non-overlapping writes, and a single broad investigation is not treated as batch fan-out.