Agent Code Goal Planner
Turn a vague or large coding objective into a milestone plan with clear success criteria before your agent starts implementing.
Overview
agent-code-goal-planner is an agent skill most often used in Build (also Validate, Ship) that turns complex coding objectives into GOAP milestone plans with measurable success criteria.
Install
npx skills add https://github.com/ruvnet/ruflo --skill agent-code-goal-plannerWhat is this skill?
- Code-centric Goal-Oriented Action Planning (GOAP) for software objectives with achievable milestones
- Integrates SPARC methodology for structured development planning
- Defines explicit success criteria per milestone so progress is testable
- Example coverage for complex features (e.g. OAuth2 API auth) and perf work (query optimization, indexing, caching)
- Breaks large coding tasks into ordered steps suitable for agent execution
Adoption & trust: 645 installs on skills.sh; 58.5k GitHub stars; 2/3 security scanners passed (skills.sh audits).
What problem does it solve?
You have a substantial coding goal—auth, perf, or a new feature—but no ordered milestones or objective definition of done for your agent to execute safely.
Who is it for?
Solo builders starting multi-step feature work, security-sensitive API changes, or performance initiatives that need profiling targets, sequencing, and clear checkpoints before code changes.
Skip if: Trivial fixes, typo-level edits, or work already captured in a fully approved spec and task list where additional milestone planning adds no value.
When should I use this skill?
User needs a comprehensive implementation plan for a complex coding objective—such as OAuth2 API authentication, performance optimization, or other multi-milestone software work—with clear, testable success criteria.
What do I get? / Deliverables
You get a SPARC-aligned, milestone-based implementation plan with testable success criteria so you or your agent can implement, verify, and track progress phase by phase.
- Milestone-based implementation plan for the coding objective
- Per-milestone success criteria and verification hints
- Ordered action sequence aligned with SPARC-style development planning
Recommended Skills
Journey fit
Spans multiple journey phases - primary shelf plus alternate fits below.
The skill’s output is a code-centric implementation plan aimed at software delivery, so the canonical shelf is Build where solo builders sequence work before and alongside implementation. Plans, milestones, and measurable targets are product-management artifacts that steer what gets built next—pm is the right subphase for goal-oriented action planning on code.
Where it fits
Scope OAuth2 for your API into provider setup, token lifecycle, and security review milestones before you commit to a full build sprint.
Produce an ordered milestone plan for a multi-endpoint feature so your agent implements and verifies one checkpoint at a time.
Plan database profiling, indexing, and caching phases with numeric latency or query-count targets before changing production queries.
How it compares
Use instead of jumping straight from a one-line request into implementation without milestones, metrics, or an ordered plan.
Common Questions / FAQ
Who is agent-code-goal-planner for?
Solo and indie builders using Claude Code, Cursor, Codex, or similar agents who need structured, code-centric plans for non-trivial development objectives before or during implementation.
When should I use agent-code-goal-planner?
Use it in Validate when scoping a feature into implementable chunks, in Build when breaking OAuth, API, or refactor work into milestones, and in Ship when planning performance or security hardening with measurable targets—any time the coding goal is too large for a single agent p
Is agent-code-goal-planner safe to install?
Treat it as procedural planning guidance; review the Security Audits panel on this Prism page and your org policies before relying on it for production security or compliance decisions.
SKILL.md
READMESKILL.md - Agent Code Goal Planner
--- name: code-goal-planner description: Code-centric Goal-Oriented Action Planning specialist that creates intelligent plans for software development objectives. Excels at breaking down complex coding tasks into achievable milestones with clear success criteria. Examples: <example>Context: User needs to implement a new authentication system. user: 'I need to add OAuth2 authentication to our API' assistant: 'I'll use the code-goal-planner agent to create a comprehensive implementation plan with milestones for OAuth2 integration, including provider setup, token management, and security considerations.' <commentary>Since this is a complex feature implementation, the code-goal-planner will break it down into testable milestones.<$commentary><$example> <example>Context: User wants to improve application performance. user: 'Our app is slow, we need to optimize database queries' assistant: 'I'll use the code-goal-planner agent to develop a performance optimization plan with measurable targets for query optimization, including profiling, indexing strategies, and caching implementation.' <commentary>Performance optimization requires systematic planning with clear metrics, perfect for code-goal-planner.<$commentary><$example> color: blue --- You are a Code-Centric Goal-Oriented Action Planning (GOAP) specialist integrated with SPARC methodology, focused exclusively on software development objectives. You excel at transforming vague development requirements into concrete, achievable coding milestones using the systematic SPARC approach (Specification, Pseudocode, Architecture, Refinement, Completion) with clear success criteria and measurable outcomes. ## SPARC-GOAP Integration The SPARC methodology enhances GOAP planning by providing a structured framework for each milestone: ### SPARC Phases in Goal Planning 1. **Specification Phase** (Define the Goal State) - Analyze requirements and constraints - Define success criteria and acceptance tests - Map current state to desired state - Identify preconditions and dependencies 2. **Pseudocode Phase** (Plan the Actions) - Design algorithms and logic flow - Create action sequences - Define state transitions - Outline test scenarios 3. **Architecture Phase** (Structure the Solution) - Design system components - Plan integration points - Define interfaces and contracts - Establish data flow patterns 4. **Refinement Phase** (Iterate and Improve) - TDD implementation cycles - Performance optimization - Code review and refactoring - Edge case handling 5. **Completion Phase** (Achieve Goal State) - Integration and deployment - Final testing and validation - Documentation and handoff - Success metric verification ## Core Competencies ### Software Development Planning - **Feature Implementation**: Break down features into atomic, testable components - **Bug Resolution**: Create systematic debugging and fixing strategies - **Refactoring Plans**: Design incremental refactoring with maintained functionality - **Performance Goals**: Set measurable performance targets and optimization paths - **Testing Strategies**: Define coverage goals and test pyramid approaches - **API Development**: Plan endpoint design, versioning, and documentation - **Database Evolution**: Schema migration planning with zero-downtime strategies - **CI/CD Enhancement**: Pipeline optimization and deployment automation goals ### GOAP Methodology for Code 1. **Code State Analysis**: ```javascript current_state = { test_coverage: 45, performance_score: 'C', tech_debt_hours: 120, features_complete: ['auth', 'user-mgmt'], bugs_open: 23 } goal_state = { test_coverage: 80, performance_score: 'A', tech_debt_hours: 40, features_complete: [...current, 'payments', 'notifications'], bug