agentleFS
MicrosoftKnown publishermicrosoft/devsquad-copilot/.github/plugins/devsquad/skills/complexity-analysis/SKILL.md

complexity-analysis

Skill50 starsChanged 16 days agoMITView on GitHub

Complexity analysis for user stories with known work, risks, and scenarios. Use when you need to estimate effort, points, size, or analyze complexity of a user story. Do not use for sprint estimates (use devsquad.sprint) or for artifact quality validation (use quality-gate).

We split this skill into the rules it gives an agent

8 rules. About 0 are common, 8 are distinctive, and 0 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈8

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 0

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    Every classification (known/unknown) must cite the evidence that supports it.

    line 12
  2. Distinctive:

    Before proposing scenarios, list decisions or information that need a human response:

    line 49
  3. Distinctive:

    Do not give a number without justification (e.g., "3 story points")

    line 111
  4. Distinctive:

    Do not ignore risks to appear faster

    line 112
  5. Distinctive:

    Do not list only known work

    line 113
  6. Distinctive:

    Do not present a single scenario as "the solution"

    line 114
  7. Distinctive:

    Do not hide assumptions: always make them explicit

    line 115
  8. Distinctive:

    Do not claim confidence you do not have: declare the uncertainty

    line 116

≈ “Common” is an estimate: at least 1 in 5 of the 308,232 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Principle

Focus on the unknowns, not the knowns. Unknown work dominates software projects.

Evidence Rule

Every classification (known/unknown) must cite the evidence that supports it. Reference code, ADR, spec, or absence thereof. If uncertain, say so and indicate what information would resolve the uncertainty.

Analysis Structure

1. Known Work

Tasks whose effort can be estimated with confidence:

  • We have done something similar in this project
  • Established pattern in ADR or existing code
  • Well-defined scope in the spec
  • Existing test coverage in the affected area
  • Localized change (few impacted dependencies)

For each item, indicate why it is known (e.g., "CRUD endpoint, same pattern as src/api/users").

2. Unknown Work (Risks)

Signals of uncertainty:

  • First time (new technology, integration, or pattern)
  • External dependency (third-party API, another team's service)
  • Vague requirement ("must be fast", "easy to use")
  • Pending decision (no ADR exists for technical choice)
  • Legacy code (area without tests or documentation)
  • Concurrency/scale (behavior under load not tested)
  • Cross-team coordination without agreed interface

For each risk, indicate: what the risk is, why it is a risk, and impact if it materializes.

3. Dependencies

DependencyOwner (team/service)StatusImpact if delayed

Flag tentative dependencies, without commitment, or without agreed timeline.

4. Open Questions

Before proposing scenarios, list decisions or information that need a human response:

  • Decisions needed before starting
  • Pending requirement clarifications
  • Access or approvals not granted

5. Scenarios (2-3 approaches)

ScenarioApproachIf it goes wellIf risks materializeTrade-offs

6. Recommendation

Indicate the recommended scenario with explicit justification ("recommended because..."), linking to evidence and identified risks.

For high risks, suggest a spike or timebox to reduce uncertainty before committing.

Risk Classification

RiskCriteriaImplication
High2+ unknown risks, critical external dependency, or missing ADRMandatory supervision, consider spike
Medium1 manageable risk, or complex logicValidation checkpoints
LowOnly known work, established patternCandidate for autonomous execution

Format for Work Items

In the User Story body (GitHub/Azure DevOps):

## Complexity Analysis

**Risk:** [High/Medium/Low]

### Known Work
- Item 1 (estimate)
- Item 2 (estimate)

### Identified Risks
- Risk 1: [description and potential impact]
- Risk 2: [description and potential impact]

### Scenarios
| Scenario | Base effort | If risks materialize | Recommended? |
|----------|-------------|----------------------|--------------|
| A | X days | Y days | |
| B | X days | Y days | yes |

### Decision
[Chosen scenario and justification, or "Awaiting team decision"]

When to Revisit Analysis

The analysis should be updated when:

  • A risk materializes (document actual impact)
  • A new risk is discovered during implementation
  • The scenario decision is changed
  • A relevant ADR is created or modified

Anti-patterns

  • Do not give a number without justification (e.g., "3 story points")
  • Do not ignore risks to appear faster
  • Do not list only known work
  • Do not present a single scenario as "the solution"
  • Do not hide assumptions: always make them explicit
  • Do not claim confidence you do not have: declare the uncertainty

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.