Implementation-Approach Skill for Smarter Agent Planning

Where this fits

You're an agent tasked with refactoring a payment service. You have to decide: rewrite, patch, or preserve? Without a framework, agents jump to code and produce changes that conflict with existing architecture. This skill gives agents a decision gate: analyze current implementation, judge whether options are viable, then commit to an approach with verification criteria.

Why agents benefit

• Forces agents to ask "what does the existing implementation look like?" before emitting code, reducing speculative changes.
• Separates business essence from technical constraints, helping agents avoid deleting intentional design decisions.
• Provides a meta-cognitive checklist that stops analysis when additional facts won't change the choice, saving tokens.
• Makes verification explicit: agents define what evidence proves the selected approach works.
• Works as a reusable automation skill across planning, refactoring, and bug-fix workflows.

Practical scenarios

Backend migration from a monolithic module

An agent is asked to break a monolith into services. Instead of designing a target architecture immediately, it first maps responsibility separation, dependencies, and historical reasons for current coupling. It then picks an incremental strangler-pattern approach and defines verification criteria around API behavior parity.

Security patch with unknown legacy behavior

A legacy function has SQL injection but is called from many places. The agent can't rewrite all callers safely. Using the framework, it analyzes data flow and implicit preconditions, then selects a minimal input-validation approach with a regression test list covering all call sites.

New feature that might conflict with existing design

A request asks for real-time updates in an event-driven system. The agent evaluates current event schemas and consumer expectations before choosing between extending events or adding a new stream. The skill's "decision-sufficient analysis" stops endless exploration once the compatibility constraints are known.

Add it to your agent workflow

Install the skill via npx:

npx skills add shinpr/claude-code-workflows --skill implementation-approach

After installation, instruct your agent at the start of an implementation task:

Use the implementation-approach skill before making code changes. Analyze the current state, select an implementation strategy, and list specific verification criteria.

For a broader view of this skill and related automation skills, see the OpenAgentSkill entry: https://www.openagentskill.com/skills/shinpr-implementation-approach

Compare before adopting

Before adding any skill, compare quality signals: is the README specific enough to guide agent behavior? Check maintenance freshness: recent commits and issues make the framework more likely to work with current LLM tooling. Consider alternatives such as generic "planning" prompts; this skill earns its place by focusing on implementation strategy rather than project planning. Also evaluate workflow fit: does your agent already have a decision gate like this, or does it jump to code?

Why it is worth tracking

The GitHub repository behind this skill has 675 stars, a signal that developers are actively adopting it. More importantly, the skill targets a real gap in agent workflows: choosing an implementation approach before making changes. Watch it for updates around verification criteria and meta-cognitive prompts; if your agents are producing code that ignores existing architecture or lacks test evidence, this is the skill to try.