# Scope

> Exploratory workflow for understanding problem spaces and drafting feature proposals, refactorings, or complex bug-fixes. Creates detailed tickets in your issue tracker without doing implementation work.

- **Type:** Skill
- **Install:** `agentstack add skill-chrisallenlane-claude-swe-workflows-scope`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [chrisallenlane](https://agentstack.voostack.com/s/chrisallenlane)
- **Installs:** 0
- **Category:** [AI & ML](https://agentstack.voostack.com/c/ai-and-ml)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [chrisallenlane](https://github.com/chrisallenlane)
- **Source:** https://github.com/chrisallenlane/claude-swe-workflows/tree/master/skills/scope

## Install

```sh
agentstack add skill-chrisallenlane-claude-swe-workflows-scope
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# Scope - Problem Space Exploration & Ticket Creation

Helps you thoroughly understand a problem space through codebase exploration and iterative dialogue, then creates a well-specified ticket for future implementation.

**This skill does NOT write code.** It explores, questions, understands, and documents.

## Workflow

### 1. Initial Discovery

**Understand what the user wants to explore:**
- What feature are they considering?
- What refactoring are they contemplating?
- What bug needs detailed investigation?
- Is this greenfield or modifying existing code?

**Ask clarifying questions:**
- Scope and boundaries
- Problem statement
- Desired outcome (not implementation details yet)

Output: Clear understanding of what problem space to explore.

### 2. Codebase Exploration

**Use exploration tools to understand context:**
- Spawn `Explore` agent (set thoroughness based on scope: "quick", "medium", "very thorough")
- Use Grep to find relevant code patterns
- Use Read to examine key files identified
- Map out the current architecture/implementation

**For third-party dependencies:**
- Use WebFetch to read API documentation
- Clone relevant repositories to `/tmp` for examination if needed
- Understand integration points and constraints

**Exploration goals:**
- Where does this change fit in the architecture?
- What existing code will be affected?
- What patterns/conventions are already established?
- What are the integration points?
- What similar features exist that we can learn from?

Output: Comprehensive understanding of the relevant codebase areas.

### 3. Iterative Refinement

**Use AskUserQuestion to refine understanding:**
- Present what you've learned from exploration
- Ask about approaches (if multiple valid options exist)
- Clarify edge cases and requirements
- Discuss trade-offs between approaches
- Validate assumptions about existing code

**Loop until both Claude and user have:**
- Precise understanding of what to build
- Clear rationale for approach chosen
- Identified edge cases and constraints
- Agreed on acceptance criteria

**Important:** This is collaborative design, not just requirements gathering. Challenge assumptions, propose alternatives, discuss trade-offs.

Output: Shared, precise understanding of the work to be done.

### 4. Ticket Synthesis

**Draft ticket content adaptively based on type:**

**For feature proposals:**
- Problem statement (what problem does this solve?)
- Proposed solution (high-level approach)
- Acceptance criteria (specific, testable)
- Technical notes (implementation considerations, affected components)
- Security considerations (if the change introduces new attack surface, handles user input, touches auth/authz, or affects trust boundaries — note what controls will be needed. Consult the `sec-blue-teamer` agent if the implications are non-obvious.)
- Out of scope (what explicitly won't be done)
- Open questions (if any remain)

**For refactorings:**
- Current state (what's problematic about existing code)
- Desired state (what we want it to look like)
- Motivation (why is this worth doing)
- Approach (high-level refactoring strategy)
- Risk assessment (what could go wrong)
- Affected areas (files/modules that will change)

**For complex bug fixes:**
- Bug description (observed behavior)
- Root cause (from your exploration)
- Proposed fix (high-level approach)
- Why this happened (what allowed the bug)
- Verification plan (how to confirm fix works)
- Regression prevention (tests/checks to prevent recurrence)

**Format guidelines:**
- Use markdown
- Be specific, not vague
- Include code references (file paths, line numbers, function names)
- Link to relevant documentation or issues
- Make it actionable (someone else should be able to implement from this)

Output: Draft ticket content for user review.

### 5. Review & Refine Ticket

**Present draft to user:**
- Show complete ticket content
- Highlight any areas of uncertainty
- Ask if anything is missing or unclear

**Iterate if needed:**
- Adjust based on feedback
- Add missing details
- Clarify ambiguous sections

Output: Approved ticket content ready to create.

### 6. Create Ticket

Detect the issue tracker and create the ticket per [`references/trackers.md`](../../references/trackers.md) (Detection Procedure + "Create" operation). Capture and present the resulting ticket URL.

Output: Created ticket with URL.

## Skill Boundaries

**This skill will:**
- Explore code extensively
- Ask lots of questions
- Synthesize understanding into tickets
- Challenge your assumptions
- Propose alternatives
- Create issues in your issue tracker

**This skill will NOT:**
- Write production code
- Make commits
- Run tests or linters
- Modify files (except ticket creation)
- Implement features

## Notes

**Exploration thoroughness:**
- Quick exploration: ~5 minutes, high-level understanding
- Medium exploration: ~15 minutes, detailed component analysis
- Very thorough: ~30 minutes, comprehensive system understanding

**Ticket quality over speed:**
- Take time to understand deeply
- Don't rush to ticket creation
- Better to ask more questions than create vague tickets

**Integration with /implement:**
- These skills are separate and complementary
- `/scope` creates the ticket, `/implement` implements it
- Ticket created by `/scope` can be handed to someone else or tackled later with `/implement`

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [chrisallenlane](https://github.com/chrisallenlane)
- **Source:** [chrisallenlane/claude-swe-workflows](https://github.com/chrisallenlane/claude-swe-workflows)
- **License:** MIT

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/skill-chrisallenlane-claude-swe-workflows-scope
- Seller: https://agentstack.voostack.com/s/chrisallenlane
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.