challenge-plan

Extract assumptions, verify claims against code, and classify concerns by severity.

9.9k|1.8k|Updated Aug 8, 2016
One-click install
npx skills add https://github.com/gitkraken/vscode-gitlens --skill challenge-plan
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: challenge-plan
Source: https://github.com/gitkraken/vscode-gitlens/tree/main/.claude/skills/challenge-plan
Command: npx skills add https://github.com/gitkraken/vscode-gitlens --skill challenge-plan

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill helps identify potential flaws, hidden assumptions, and risks in technical plans, implementation strategies, or architectural decisions before they lead to costly mistakes during development.

Core Features & Use Cases

  • Assumption Extraction: Identifies and lists all explicit and implicit assumptions made in a plan.
  • Claim Verification: Cross-references factual claims in the plan against the actual codebase.
  • Pre-Mortem Analysis: Simulates failure scenarios to uncover potential problems.
  • Concern Classification: Categorizes and prioritizes identified issues by severity (Blocking, Significant, Minor).
  • Solution Proposal: Suggests fixes or alternative approaches for critical issues.
  • Use Case: Before implementing a new microservice architecture, use this Skill to rigorously challenge the proposed design, ensuring all potential pitfalls are addressed upfront.

Quick Start

Use the challenge-plan skill to stress-test the following implementation outline: [Paste your plan here].

Frequently Asked Questions about challenge-plan

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

FAQPage Schema
How do I stress-test a technical plan before implementation begins?

To stress-test a technical plan, you need to extract hidden assumptions, verify claims against the codebase, and run pre-mortem scenarios to identify and classify plan-blocking issues by severity before development starts.

What is a pre-mortem analysis in software architecture?

A pre-mortem analysis in software architecture simulates failure scenarios for proposed technical plans to uncover potential problems and hidden risks, mitigating costly mistakes before implementation begins.

How do I verify architecture decisions against my actual codebase?

You can verify architecture decisions by cross-referencing factual claims in the implementation outline against the actual codebase, categorizing and prioritizing any identified concerns by severity to ensure robustness.

Can I use this to identify hidden assumptions in an implementation outline?

Yes, you can identify hidden assumptions by analyzing the implementation outline to extract and list all explicit and implicit assumptions made in the proposed technical plan.

What is the best way to classify risks in a proposed microservice architecture?

The best way to classify risks in a microservice architecture is to challenge the proposed design, run pre-mortem scenarios, and categorize identified issues by severity levels like Blocking, Significant, or Minor.

When should I challenge a proposed technical plan?

You should challenge a proposed technical plan before implementation begins to rigorously identify potential flaws, verify claims against code, and mitigate risks, ensuring all potential pitfalls are addressed upfront.