New to Claude Skills? Learn how to install them →

ruvnet on GitHub

Goal Plan

Free

Create and execute intelligent action plans with GOAP.

by ruvnet67.6k stars on ruvnet/ruflo
1 views
Updated Aug 10, 2026
Get this skill

Free · Opens the source repo

What Goal Plan does

Goal Plan is a skill designed for developers and designers who need to manage complex objectives that involve multiple steps and dependencies. Utilizing Goal-Oriented Action Planning (GOAP), this skill allows you to define a clear goal state, assess your current situation, and identify the necessary changes to bridge the gap between the two. By systematically analyzing preconditions, effects, and costs associated with each action, you can generate an optimal action sequence to achieve your objectives efficiently.

The process begins with defining what success looks like and assessing your current state to understand what resources and conditions are available. After identifying the gap, you can inventory potential actions, detailing their preconditions and effects, along with cost estimates. The skill employs the A* algorithm to generate a plan that outlines the sequence of actions needed to reach your goal, while also allowing for real-time monitoring and adaptive replanning if conditions change or if unexpected results occur.

Goal Plan is particularly useful in scenarios where projects are dynamic and require ongoing adjustments. It provides a structured approach to project management, ensuring that you can adapt to new information or changes in circumstances without losing sight of your objectives. This makes it suitable for teams working on software development, infrastructure projects, or any complex task that necessitates careful planning and execution.

However, it is essential to note that Goal Plan may not be the best fit for simple tasks or projects with well-defined and static requirements. If your objectives are straightforward and do not involve multiple dependencies or the need for replanning, a simpler task management tool might suffice. Overall, Goal Plan is a powerful tool for those who need to navigate complexity and ensure successful project execution.

When to use it

Use Goal Plan when your project involves multiple steps and requires adaptive replanning as conditions evolve.

When not to use it

Avoid using this skill for simple tasks that do not require detailed planning or where objectives are static.

What you can build with it

Software Development Project

Utilize Goal Plan to map out the development process, ensuring all dependencies are managed and adjustments are made as requirements evolve.

Infrastructure Deployment

Create a detailed action plan for deploying infrastructure changes, allowing for real-time monitoring and replanning as conditions change.

Research Project Management

Manage a research project with multiple phases and dependencies, using Goal Plan to adapt to new findings and adjust the project trajectory accordingly.

How to install Goal Plan

View source

1. Install with the skills CLI

npx skills add ruvnet/ruflo/goal-plan --agent claude-code

2. Or install it manually

Download the skill folder and drop it into ~/.claude/skills/ for all projects, or .claude/skills/ to scope it to one repo. Restart Claude Code so it picks up the new skill.

Anthropic's agentic coding CLI, and the reference implementation of Agent Skills. Drop a skill folder into ~/.claude/skills and Claude Code loads it automatically whenever a task matches the skill's description. Claude Code docs

Inside SKILL.md

Written by ruvnet

Goal Plan

Create and execute intelligent plans using Goal-Oriented Action Planning (GOAP).

When to use

When you have a complex objective that requires multiple steps, has dependencies between steps, and may need adaptive replanning as conditions change.

Steps

  1. Define goal state — what does "done" look like? List concrete success criteria
  2. Assess current state — what's true now? What assets, code, infrastructure exist?
  3. Identify gap — what must change between current and goal state?
  4. Inventory actions — list available actions with:
    • Preconditions (what must be true before this action)
    • Effects (what becomes true after this action)
    • Cost estimate (time, complexity, risk)
  5. Generate plan — find the optimal action sequence using A* through the state space
  6. Record trajectory — call mcp__plugin_ruflo-core_ruflo__hooks_intelligence_trajectory-start to begin tracking
  7. Create tasks — call mcp__plugin_ruflo-core_ruflo__task_create for each action in the plan
  8. Execute — work through tasks in dependency order:
    • Before each action: verify preconditions still hold
    • After each action: verify effects achieved
    • Record each step via mcp__plugin_ruflo-core_ruflo__hooks_intelligence_trajectory-step
  9. Monitor & replan — if an action fails or produces unexpected results:
    • Reassess current state
    • Recalculate optimal path from new state
    • Update remaining tasks
  10. Complete trajectory — call mcp__plugin_ruflo-core_ruflo__hooks_intelligence_trajectory-end
  11. Store successful plan — call mcp__plugin_ruflo-core_ruflo__memory_store with namespace goap-plans

Plan output format

Goal: [concrete objective]
Current State: [key facts]
Plan Cost: [estimated effort]
Steps:
  1. [action] — precondition: [X], effect: [Y], cost: [Z]
  2. [action] — precondition: [Y], effect: [W], cost: [Z]
  ...
Risk Factors: [what could force a replan]
Fallback: [alternative approach if primary path fails]

Replanning triggers

  • Action fails (precondition no longer met)
  • Unexpected side effects detected
  • New information changes goal definition
  • Cost exceeds threshold
  • External dependency becomes unavailable

Frequently asked questions about Goal Plan

Similar skills