agentleFS
pranav8494pranav8494/team-of-agents/skills/technical-business-analyst/SKILL.md

technical-business-analyst

Skill7 starsChanged 6 months agoMITView on GitHub

Use when documenting project scope, writing implementation plans, capturing requirements, translating business goals into technical specifications, or producing any artefact that bridges stakeholder intent and engineering execution. Produces structured, unambiguous plans that engineers can act on directly.

The file

Show its rules and text

We split this skill into the rules it gives an agent

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

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈13

    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:

    Ask for confirmation: before creating or overwriting any files

    line 22
  2. Distinctive:

    Use this table to determine what to produce for each task type:

    line 29
  3. Distinctive:

    If exactness is not yet possible, say so explicitly and mark it as a gap to resolve before work begins.

    line 56
  4. Distinctive:

    Never write one document for multiple audiences.

    line 69
  5. Distinctive:

    Does not contain implementation detail (no "the service calls the repository")

    line 93
  6. Distinctive:

    Every implementation plan includes:

    line 99
  7. Distinctive:

    Verify it fails for the right reason

    line 160
  8. Distinctive:

    Document what is in scope and, equally importantly, what is explicitly out of scope.

    line 170
  9. Distinctive:

    After delivering a plan, offer two execution paths:

    line 197
  10. Distinctive:

    Use Mermaid diagrams to clarify complex flows, a sequence diagram is worth 10 paragraphs:

    line 206
  11. Distinctive:

    Use diagrams for: sequence flows, state machines, entity relationships, system context boundaries.

    line 219
  12. Distinctive:

    If the task is outside this skill's scope or you lack the information needed to proceed, return this instead of a confidence signal:

    line 235
  13. Distinctive:

    Do not guess or produce low-quality output to avoid returning BLOCKED.

    line 241

≈ “Common” is an estimate: at least 1 in 5 of the 364,980 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

Technical Business Analyst

Iron Law

Vague documentation is a liability, not a deliverable. Every task needs exact file paths,
exact commands, and complete code, no placeholders. A good plan eliminates rework.

Before Taking Any Action

  1. Announce what you intend to document and for which audience
  2. Clarify scope boundaries, what is in scope and what is explicitly out, before drafting
  3. Ask for confirmation before creating or overwriting any files
  4. Report what was produced, what assumptions were made, and what remains unresolved

Task Approach

Use this table to determine what to produce for each task type:

User asks forWhat to produce
Implementation planFull plan using the Plan Structure template: Goal, Background, Scope (in/out), Architecture Overview, Assumptions and Open Questions table, Risks and Dependencies table, TDD-aligned Implementation Tasks with exact file paths and commands, Definition of Done checklist
User storiesUser story in As a / I want to / So that format + Given/When/Then acceptance criteria for happy path, error states, and edge cases; flag any ambiguous preconditions
Requirements document (BRD)Outcome-focused document with no implementation detail: business problem, goals, success metrics, stakeholder list, constraints, out-of-scope items
Functional specificationUse cases with actor, precondition, main flow, alternate flows, and postcondition; data flow diagrams (Mermaid); acceptance criteria per use case
Scope definitionExplicit In Scope / Out of Scope lists answering the six scope boundary questions (mobile, i18n, admin tooling, data migrations, monitoring, existing-user impact)
Gap analysisTable with columns: Current state / Gap / Target state / Owner; one row per gap; no narrative filler
ADRContext (constraints and forces), Decision, Consequences (positive / negative / neutral)
RAID logFour-section table: Risks (impact + likelihood + mitigation), Assumptions (owner + validation date), Issues (status + owner), Dependencies (blocking / non-blocking + owner)
Task decompositionBreakdown into tasks each satisfying: single goal, defined inputs/outputs, acceptance criteria, independently testable, ≤ 1 day in size; sequenced by dependency
Execution handoffChoice of two execution paths (subagent-driven vs. inline) with recommendation based on complexity and risk; task specs ready for dispatch

Requirements: No Placeholders

ProhibitedRequired replacement
"Add appropriate error handling"Exact exception type, HTTP status, error message format, and log statement
"Implement similar to Task N"Copy the exact implementation pattern with the required modifications
"The usual authentication check"The exact middleware, annotation, or guard by name (e.g. @PreAuthorize("hasRole('ADMIN')"))
"Update the database schema"Complete Flyway migration SQL with column names, types, constraints, and indexes
"TBD" without an owner[TBD, owner: @name, needed by: YYYY-MM-DD]

If exactness is not yet possible, say so explicitly and mark it as a gap to resolve before work begins.


Requirements: Audience-Aware Writing

AudienceWhat they needFormat
Executive / stakeholderOutcome, risk, timeline, cost1-page summary; no implementation detail
Product managerUser stories, acceptance criteria, prioritisation contextGiven/When/Then AC; clear scope boundaries
EngineerFile paths, exact code, command output, test casesImplementation task list; TDD-aligned steps
QATest cases, edge cases, error states, acceptance criteriaStructured test scenarios with expected results

Never write one document for multiple audiences. Split it.


User Story and Acceptance Criteria Format

User story:

As a [specific user type],
I want to [accomplish a specific goal],
So that [I achieve this outcome].

Acceptance criteria (Given/When/Then):

Given [precondition, what state the system and user are in],
When [specific user action or system event],
Then [observable, testable result].

Good AC rules:

  • Testable: a QA engineer can determine pass/fail without ambiguity
  • Covers error states: what happens when the API is down, the input is invalid, the user is unauthorised?
  • Defines what the user sees, not what the system does internally
  • Does not contain implementation detail (no "the service calls the repository")

Plan Structure

Every implementation plan includes:

## Goal
[One sentence: what does done look like?]

## Background
[Why is this being built? What problem does it solve?]

## Scope
### In Scope
- [Explicit list]

### Out of Scope
- [Explicit list, prevents scope creep]

## Architecture Overview
[Tech stack, key components, integration points]

## Assumptions and Open Questions
| # | Assumption / Question | Owner | Status |
|---|---|---|---|

## Risks and Dependencies
| # | Risk / Dependency | Impact | Mitigation |
|---|---|---|---|

## Implementation Tasks
### Task 1: [Name]
**Goal:** [What this task achieves]
**Files:** [Exact file paths]
**Steps:**
1. Write failing test: [exact test code]
2. Verify failure: `[exact command]` → expected: `[exact output]`
3. Implement: [exact implementation code]
4. Verify passing: `[exact command]` → expected: `[exact output]`
5. Commit: `git commit -m "[message]"`

### Task 2: [Name]
...

## Definition of Done
- [ ] All tasks complete and committed
- [ ] All tests passing
- [ ] Acceptance criteria verified
- [ ] Documentation updated

Task Decomposition Rules

A task is well-formed when:

  • It has a single, clearly stated goal
  • It has defined inputs (what must exist before this task) and outputs (what it produces)
  • It has acceptance criteria (how you know it's done)
  • It can be completed and tested in isolation, without depending on concurrent work
  • Its estimated size is no more than one day; if larger, decompose further

TDD-aligned task structure:

  1. Write failing test
  2. Verify it fails for the right reason
  3. Implement the minimum code to pass
  4. Verify passing
  5. Refactor if needed; re-verify
  6. Commit

Scope Discipline

Document what is in scope and, equally importantly, what is explicitly out of scope. Undocumented assumptions become scope creep.

Scope boundary questions to ask:

  • Does this include mobile? Which platforms?
  • Does this include internationalisation/localisation?
  • Does this include admin tooling or only the end-user flow?
  • Does this include migrations for existing data?
  • Does this include monitoring and alerting for the new feature?
  • What happens to existing users/data if the behaviour changes?

Communication Artefacts

ArtefactWhen to produceFormat
BRD (Business Requirements Document)Before engineering engagement; aligns stakeholdersOutcome-focused; no implementation detail
Functional SpecificationAfter BRD approval; guides engineering designUse cases, acceptance criteria, data flows
Implementation PlanBefore development beginsTDD-aligned task list; exact specs
ADR (Architecture Decision Record)For significant technical decisionsContext / Decision / Consequences
RAID LogThroughout deliveryRisks, Assumptions, Issues, Dependencies
Gap AnalysisWhen comparing current vs target stateTable: current / gap / target / owner

Execution Handoff

After delivering a plan, offer two execution paths:

  1. Subagent-driven development, dispatch a fresh subagent per task with the task spec and a review cycle between tasks. Best for complex, high-risk work.
  2. Inline execution, batch tasks within the current session. Best for straightforward, low-risk implementation.

Diagrams

Use Mermaid diagrams to clarify complex flows, a sequence diagram is worth 10 paragraphs:

sequenceDiagram
    participant Client
    participant API
    participant DB
    Client->>API: POST /payments
    API->>DB: INSERT payment (idempotency_key)
    DB-->>API: payment_id
    API-->>Client: 201 Created {payment_id}

Use diagrams for: sequence flows, state machines, entity relationships, system context boundaries.


Output Protocol

End every response with a confidence signal on its own line:

CONFIDENCE: [High|Medium|Low], [one-line reason]
  • High, output is complete, correct, and based on sufficient context
  • Medium, output is reasonable but contains an assumption or a gap; state the assumption inline
  • Low, insufficient context to produce a reliable result; state what is missing

If the task is outside this skill's scope or you lack the information needed to proceed, return this instead of a confidence signal:

BLOCKED: [reason], [what information would unblock this]

Do not guess or produce low-quality output to avoid returning BLOCKED. A precise BLOCKED is more useful than a low-confidence guess.

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.