Integration Superpowers + GSD: skill invokes agent that executes plan

Superpowers and Get Shit Done are useful separately. They become a unique system when a skill triggers an agent spawn, GSD, which executes a specific plan. This is the point at which the two frameworks stop being separate toys. This is the last cluster of the series and describes the integration pattern I use daily.

Independence Disclaimer: I am not affiliated with Obra, qrx, or Anthropic. The described pattern is the consolidated workflow on the brownfield portfolio after ~12 months of parallel use of both frameworks.

The fundamental pattern

A superpower active (e.g. XPHX0XPHX, XPHX1XPHX) code-reviewerDuring the process, it discovers a situation X that requires structured planning (e.g., cross-file duplication which deserves a dedicated refactoring phase). The skill, instead of just reporting on this, suggests a command GSD The template. The template presents the command to the user for confirmation. User confirms. GSD takes control: creates phase, discusses, plans, and eventually executes.

Without integration: you (the user) must understand on your own that the report skill requires a phase of refactoring, launching commands GSD manually. With integration: skill proposes commands, you approve in 3 clicks.

Trigger pattern: skills that recognize "GSD-worthy moments"

Every skill in my portfolio has been extended in the body with a section that identifies "situations that warrant GSD". Examples: Note: The original text contains the token XPHX0XPHX, which is preserved exactly as-is in the translation.

• Code reviewer Find ≥3 MEDIUM duplication in cross-file → suggests /gsd-phase <descrizione refactor>.
• Brainstorming session reaches phase Converge with 2+ alternative equivalents and long-term tradeoffs → suggests /gsd-discuss-phase N To formally capture the decision.
• debugging Identify cause of a bug that requires cross-cutting modifications to 3+ modules → suggests /gsd-phase <descrizione hotfix multi-modulo>.
• Test-Driven Development (TDD) Guide Encounter with a complex feature (10+) Edge case → Suggests /gsd-phase <feature> To plan proper coverage matrix instead of ad-hoc TDD.

Example synthetic: skill code-reviewer + /gsd-phase

Typical Session Summary (Note: Literal Transcript) Session Summary: * The customer requested a quote for a new project. * The sales representative provided a detailed breakdown of the costs and timeline. * The customer asked about the possibility of a discount due to the current economic climate. * The sales representative explained that discounts are not typically offered during this time period. * The customer inquired about the availability of alternative products that could meet their needs at a lower cost. * The sales representative suggested a few options and provided pricing information. * The customer decided to proceed with the original product selection. * The sales representative confirmed the order and provided a timeline for delivery. Please note that I've kept the formatting, punctuation, and capitalization style consistent with the original text.

[Modello scrive feature X in 5 file]

[Skill code-reviewer auto-invocata post-write]

Code Review Report:
  CRITICAL: 0
  HIGH: 0
  MEDIUM: 3
    - Duplicazione validazione fra src/payment/checkout.ts:42
      e src/payment/refund.ts:67
    - Duplicazione di errore mapping fra src/checkout.ts:80
      e src/payment-method.ts:55
    - Naming inconsistente: paymentMethod vs payment_method
      vs pm in 4 file

[Skill detect: 3 MEDIUM duplicazione cross-file = GSD-worthy]

Suggestion:
  Queste 3 MEDIUM indicano debito strutturale che merita una
  fase refactor dedicata invece di fix puntuali. Posso lanciare:

  /gsd-phase "Consolidate payment validation + error mapping +
              naming consistency cross-file"

  Procedere? [Y/n]

User confirmation. GSD /gsd-phase create phase in ROADMAP + directory in .planning/phases/From there the GSD workflow standard (discuss → plan → execute).

Pattern: skill that reads GSD state

Inverse: skill that uses information from .planning/STATE.md context-aware decisions.

Example. Skill debugging Custom extended: before starting investigation, read STATE.md to understand the current phase. If the current phase is Phase 17 (Search Console Fix), the body of the skill adjusts priority hypotheses (canonical, hreflang, INP mobile before other causes).

Pattern: skill of domain + current state = most informed hypothesis. General skill would have evaluated all causes with equal weight.

Pattern: GSDF that uses skill during execution

Double inverse: during execution of a GSD plan, gsd-executor can invoke skills during the process.

Example (summary). Plan 20-02 (Phase 20 backend) includes the task "Implement LeadMagnetController endpoint extension". The executor while writing the controller, automatically invokes a skill tdd-guide new business logic + skill code-reviewer Post-write + Skill security-reviewer on an endpoint exposed.

The three skills rotate inside The context of an execution orchestrated. GSD provides macro structures; skills provide quality at a micro level.

Maintain human-in-the-loop

Critical: skills do not launch commands GSD destructively without user confirmation. The pattern is confirm suggestionI'm ready to translate. Please provide the Italian text. auto-execute.

User control maintenance:

• Skill proposes commands.
• Template presents command and rationale.
• User approves or rejects explicitly.
• If approved, the model will execute the command GSD.

Exception: workflow YOLO mode (config workflow_mode: yolo In .planning/config.json), auto-confirmation of some commands is used. Only for low-risk tasks (e.g. /gsd:captureCommands that modify ROADMAP or spawn execute remain confirmed required even in YOLO.

When NOT to integrate

1. Skill on task one-shotWrite a skill, use it once. It's not worth extending with GSD suggestions.
2. GSD on small projects5-10 files in total. GSD is overkill, skill alone are enough.
3. Exploratory SessionsDuring exploration, nothing Automatic suggestions. Leave space for free-thinking. Integration kicks in after exploration.

Anti-pattern: skill that automate GSD without confirmation

The worst error: a skill that calls directly /gsd-execute-phase No user confirmation. Risk: execute part while you thought you were only discussing the problem. Plan partially completed, commit of premature fixes.

Mitigation strict: propose skills command GSD but do not execute them. Model presents. User approves.

Anti-pattern: too many skills that propose GSD

If every skill suggests GSD to every opportunity, the workflow becomes "every message a new phase". Counter-productive.

Heuristic: skill proposes GSD only when the situation is Clearly GSD-worthyExamples that I considered and discarded:

• Code reviewer finds 1 MEDIUM → NO. Fixes punctually is enough.
• Brainstorming reaches Converge with 1 strong recommendation → NO. It's already decided.
• Debugging solves precise bugs → NO. Sufficient skill.

Threshold for suggesting GSD: situation requires changes to 3+ files or decisions that last months.

Minimum setup to test integration

1. Abilità code-reviewer Di Superpowers active (auto-invoking post-write).
2. The GSD has been installed + .planning/ initialized.
3. Extend the body of the skill code-reviewer with a section titled "GSD-worthy moments" that proposes /gsd-phase You find ≥3 MEDIUM cross-file.
4. Test on a realistic PR. Verify that the suggested appears + confirms the human-in-loop function.

Series Conclusion

This is the last cluster of the series. 18 articles that cover Superpowers (6), GSD (6), Claude Code platform (4), cross-framework workflow (2). The integration pattern described here is the point of synthesis: the two frameworks are not competitive, but complementary. One provides macro structure (planned planning), the other provides micro quality (skill for every moment of the workflow). Together they form a meta-IDE that does not live in the editor but in the repository files.

What I've learned writing this series

18 clusters + cornerstone + 2 sub-pages = 21 articles, ~80k words written. The meta-cognitive lesson is that Write the workflow Explicitly makes the workflow betterPattern that I used instinctively have become documented, shareable, iterable patterns. The series was not only content for readers; it was an exercise in personal consolidation of the knowledge that had been quietly accumulated.

According to insight: publishing with independence disclaimer and balanced tone (mix of partisan + pragmatic + honest pro/con) creates more trust than a partisan post-enthusiastic. When I say "Cursor is better for IDE-native pair-programming" while using Claude Code + Superpowers + GSD, my final recommendation carries more weight because I recognized the true tradeoffs.

Avoided patterns throughout the series

• Selling the workflow as a productNo Premium tier "GSD Setup Personalized €200 + 1h call". Educational series, non commercial.
• Code examples for production-readyFragment illustrations always, never requested for runnables mission-critical. Reduce risk of obsolescence framework.
• Skills that I automate GSDHuman-in-loop always.

A story worth sharing

Final reference section. If you have integrated Superpowers + GSD into your workflow and want to tell me what works (or what you've modified compared to the described pattern here), write to me at federico@federicocalo.devThe pseudonymized stories (with explicit consent) will be cited in update articles of the series and in the PDF lead magnet "Workflow Agentico 2026: 18 patterns from the portfolio".

Thank you for arriving until the last cluster. Good workflow.

Return to the cornerstone of the series Previous cluster: Debug-skill end-to-end