Skip to content
Skills Library
Management & product · Analysis

current-state-map

/current-state-map

Maps a workflow exactly as it is done today and prices every step: touch time, handoffs, delay, failure and rework, totalled into cost per unit with sources and the most expensive step. Use when the user lists an as-is process with times or rates and asks how it is done today, what one unit really costs, or where the time and money go. Not for the theoretical floor and build gap (use unit-cost-floor-gap).

Repository
skills ↗
Licence
Apache-2.0
Last repository change
11.11.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
13
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 11.11.2026, without references to retired models or APIs.

Licence

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

What it does and when to use it

Maps a workflow exactly as it is done today and prices every step: touch time, handoffs, delay, failure and rework, totalled into cost per unit with sources and the most expensive step. Use when the user lists an as-is process with times or rates and asks how it is done today, what one unit really costs, or where the time and money go. Not for the theoretical floor and build gap (use unit-cost-floor-gap).

Original author description

Maps a workflow exactly as it is done today and prices every step: touch time, handoffs, delay, failure and rework, totalled into cost per unit with sources and the most expensive step. Use when the user lists an as-is process with times or rates and asks how it is done today, what one unit really costs, or where the time and money go. Not for the theoretical floor and build gap (use unit-cost-floor-gap).

How it works

  1. What it does
  2. The Icarus reframe
  3. When to use / When NOT
  4. Method
  5. Evidence standard
  6. Gotchas
  7. Examples
  8. Related skills
Original SKILL.md headings · 85 lines, 1,776 words
SKILL.md preview
---
name: current-state-map
description: >-
  Maps a workflow exactly as it is done today and prices every step: touch time, handoffs, delay,
  failure and rework, totalled into cost per unit with sources and the most expensive step. Use
  when the user lists an as-is process with times or rates and asks how it is done today, what one
  unit really costs, or where the time and money go. Not for the theoretical floor and build gap
  (use unit-cost-floor-gap).
type: generator
supersedes: none
---
# Current State Map

## What it does
Turns "how is this done today?" into an invoice. It walks the workflow as it actually happens — one row per step — and puts a sourced price on each: touch labour, the handoff tax between steps, the cost of delay, and the cost of failure and rework. The lines total into the current priced practice per unit ([template.md](template.md)), and the map names the single step that holds the most money. That total is the number `unit-cost-floor-gap` divides against the theoretical floor. This is not a swim-lane diagram and not a problem-space frame. It is a priced ledger of today's work, sourced to artefacts, tagged on the evidence ladder.

## The Icarus reframe
A generic workflow map is a swim-lane: boxes and arrows that show what happens and price nothing. When it does price, it prices only the touch labour you can see — the minutes a person spends hands-on — and misses the three costs that usually dominate: the handoff tax in the seams, the delay while the clock runs, and the failure tail when a bad output escapes. Icarus refuses an unpriced box. Every step carries a number, and every number cites the artefact it came from — a timesheet, an invoice, a ticket log, one timed run — or it is marked an opinion and the map is declared not ready. The reframe of MITRE's "who benefits when the problem exists?" is blunt here: the beneficiary of the status quo is the priced line item automation deletes, and the map shows you exactly which one.

## When to use / When NOT
Use it when you have a real workflow that happens today and you want to know what one pass through it actually costs, step by step, with the money sourced.

| Situation | Use this? | Go to |
|---|---|---|
| "How is this done today? Map it and price every step." | Yes | current-state-map |
| "What does one pass through this workflow cost us now?" | Yes | current-state-map |
| "Where does the time and money go in this process?" | Yes | current-state-map |
| "What should this cost / is the gap big enough to build?" | No | `unit-cost-floor-gap` (feed it this map's total) |
| "Strip this job to its primitive — information, decisions, liability." | No | `job-in-primitives` |
| "What's the TAM / total market for this?" | No | `bottoms-up-market-sizing` |
| "Frame the problem space — biases, who's affected, How Might We." | No | `problem-framing-canvas` |

This skill prices today's workflow and stops. It does not compute a floor, a gap, or a market. If the fellow wants those, name the sibling and hand off.

## Method
Work the ledger in [template.md](template.md). Do not narrate the process; fill the rows. Every number carries a tag: `[Fact]` (from a cited priced artefact or a directly observed run), `[Assumption]` (a stated, defensible estimate), `[Hypothesis]` (a guess flagged as needing evidence). Every number carries a source cell.

**Step 1 — Name the unit and its trigger.** One pass through the workflow that produces one output (one report, one permit, one reconciled invoice) and what kicks it off. State frequency. If the fellow cannot name a discrete unit, stop and ask for it. Invent nothing.

**Step 2 — Walk the as-is steps in order.** How the work *actually* happens, not the written SOP and not the future with your product in it. One row per step: actor/role, the artefact it consumes or produces, and touch minutes.

**Step 3 — Price touch labour.** Touch minutes × loaded rate (salary + overhead + benefits, not base). Cite the source of the minutes in each row.

**Step 4 — Add the handoff tax.** Count every handoff — work passing between people or systems. Each one costs coordination: waiting for the right person, reloading context, re-explaining. Price it. The cost of a workflow often lives in the seams, not the steps.

**Step 5 — Price delay separately from labour.** Elapsed time is not touch time. Idle waiting costs money only if the clock costs money — carrying cost, an SLA penalty, a rig standing idle, a decision that decays, a customer who churns. If delay is free, write £0 and say why. Never inflate free waiting into a fake cost.

**Step 6 — Price failure and rework.** Two lines. (a) Rework loop = P(bounce) × cost of redo. (b) Escaped failure = P(bad output reaches the customer) × cost of that failure. A rare, expensive tail can dominate the whole map. If you cannot source it, tag it `[Hypothesis]` and flag it. Do not drop it to keep the map tidy, and do not invent a number to fill it.

**Step 7 — Total = touch + handoff + delay + failure.** This is the current priced practice per unit. It is the number `unit-cost-floor-gap` divides against the floor.

**Step 8 — Cost concentration.** Rank the steps by cost. Name the single step that holds the most. That is where the product must bite first, and it foreshadows the automatable part (floor part A) and the irreducible judgment (floor part B) the next skill will separate.

**Step 9 — Map-readiness verdict.** The total is only as trustworthy as the evidence under its biggest cost line. Apply the gate.

| Condition | Verdict |
|---|---|
| Every step priced; the dominant cost line sits at ladder ≥ 0.7 | READY — the total is trustworthy; hand to `unit-cost-floor-gap` |
| The dominant cost line (> 40% of total) sits at ladder ≤ 0.3 | NOT READY — source that line first; name the cheapest artefact, then re-total |
| Any step has a blank cost | AUTO-FAIL — an unpriced step is not a map |
| Any price cites no artefact | that cell is an opinion (0.1); if it is the dominant line → NOT READY |
| Unpriced `[Hypothesis]` tail whose plausible magnitude could exceed the priced total — *dominant-suspect* | NOT READY — an unpriced line that could be the biggest one means the total may be the small half; price the tail (failure rate × £/failure) before trusting the figure |
| Unpriced `[Hypothesis]` tail that sits outside an otherwise-sourced holding total and cannot plausibly exceed it — *upside-risk* | READY — the total holds; carry the tail flagged as an upside-risk number to price before scaling |

**Kill line: an unpriced step, or a price with no cited source, fails the map.** The priced ledger is the product. A swim-lane with no money on it, or numbers invented rather than sourced from the fellow's artefacts, is not this skill's output.

## Evidence standard
The prices are where fellows guess. Each must sit on money or behaviour, not opinion. Weight every line by the evidence ladder.

| Source for a priced line | Ladder weight |
|---|---|
| Invoice / rate card / timesheet with £ against the step (money moved) | 1.0 |
| A directly timed run or a ticket/system log (behaviour observed) | 0.7 |
| A process doc or template that implies the step but not its cost (artefact shown) | 0.5 |
| "The team says it's about a day" (verbal commitment) | 0.3 |
| The fellow's opinion of what it costs | 0.1 |

A confident aggregate — "it takes two weeks and costs a fortune" — is a 0.1 opinion, not a total. The skill decomposes it into steps and demands a source per step; it never accepts the lump sum and never floors it downstream. The dominant cost line sets the map's confidence: a £/unit total whose biggest term is a guess is a hypothesis wearing a decimal point. When a line is weak, name the cheapest artefact that lifts it: pull one timesheet week, time one run with a stopwatch, export one month of the ticket log.

## Gotchas
- **Conflating elapsed time with touch time.** "It takes two weeks" prices nothing — six of those days may be idle waiting that costs £0, and the touch labour may be six hours. Separate the clock from the labour or the total is fiction.
- **Pricing the official SOP, not the real practice.** The documented process and the actual one diverge. The cost hides in the undocumented chases, reworks, and Slack messages. Map what happens, not what is written down.
- **Dropping the failure tail because it is hard to source.** A rare, expensive failure — a missed gas leak, a line stoppage, a mispriced SLA — can exceed all the touch labour combined. Tag it `[Hypothesis]`, name the two numbers that would price it, and flag it. Never drop it; never invent it.
- **Counting only the people you can see.** The handoff tax and the delay cost are invisible on a swim-lane and often beat the touch labour. A map that prices only the obvious steps understates the prize and points the product at the wrong step.
- **A tidy total hiding a guessed dominant line.** A per-unit number feels solid the moment it has a decimal point. If its largest term rests on a 0.1 opinion, the concentration gate must catch it and hold the verdict at NOT READY.

## Examples
- [examples/sample.md](examples/sample.md) — Azraq's static site risk report, decomposed and priced: five touch steps + rework loop + handoff tax reconcile to the £960 analyst-day, delay priced at £0 (and why), the failure tail flagged `[Hypothesis]`, drafting named as the dominant £300 line. Feeds `unit-cost-floor-gap` directly.

## Related skills
- `unit-cost-floor-gap` — divides this map's total (the current cost) against the theoretical floor to return the build/walk gap verdict. Run this first; it produces the number that skill needs. This skill never computes a floor or a gap.
- `job-in-primitives` — strips the same job to information moved / decisions made / liability transferred, with tool and role names deleted. The opposite move: this map keeps every tool, role, and handoff visible because that is where the cost sits.
- `product-as-decision` — names the one decision the workflow exists to make easier; this prices the whole workflow around it.
- `bottoms-up-market-sizing` — multiplies the per-unit cost across units to size the market; this builds the per-unit cost it multiplies.
- `problem-framing-canvas` — the qualitative problem-space frame (biases, who is affected, How Might We). Supersedes nothing: this absorbs its "map how it actually happens" and "who benefits from the status quo" moves and reforges them as a priced ledger, where the beneficiary of the status quo is the line item automation deletes.
Files in this package (13)
  • SKILL.md 10 KB
  • template.md 4 KB
  • examples/sample.md 4 KB
  • tests/RESULTS.md 5 KB
  • tests/rubric.json 1 KB
  • tests/adversarial/01.md 1 KB
  • tests/adversarial/02.md 1 KB
  • tests/adversarial/03.md 1 KB
  • tests/golden/01.md 2 KB
  • tests/golden/02.md 2 KB
  • tests/golden/03.md 2 KB
  • tests/golden/04.md 1 KB
  • tests/golden/05.md 1 KB

Versions

The database has no other skills named current-state-map.

Database snapshot: 13.11.2026 · package version 27e7123d6b42 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100unit-cost-floor-gap
    Sizes the per-unit prize of a piece of work: today's cost per unit versus its floor once AI does the automatable part (compute cost plus remaining human judgment minutes), as a gap ratio with a build or walk verdict. Use when the user gives one unit of work with its time or cost…
  • 100okhp3-as-is-process-capture
    Capture and normalise a current-state process description into a structured as-is process YAML with stable step identifiers. Use this skill when the user has a process that is already running and needs to document its current state before gap analysis or redesign; when they…
  • 100okhp3-as-is-process-capture
    Capture and normalise a current-state process description into a structured as-is process YAML with stable step identifiers. Use this skill when the user has a process that is already running and needs to document its current state before gap analysis or redesign; when they…
  • 100value-stream-mapping
    Build current-state and future-state value stream maps for a business or delivery process, quantifying process time, wait time, percent complete and accurate, lead time, and flow efficiency, and identifying the eight wastes. Use when a process is slow, handoff-heavy, or full of…
  • 100kaizen-map
    Map a business process from interviews, notes, emails, procedures or a description: SIPOC, current-state step table with times and waste, swimlane diagram, and a real BPMN 2.0 file that opens in bpmn.io, Camunda or Signavio. Use when the user says "map this process", "process…
  • 100pm-ground
    Step 01 of the AI Product Management workflow. Use when someone wants to "walk through how the work happens today", "map the current process", "ground the project", "interview me about the workflow", or after pm-setup finishes. Interviews the person who owns the problem about…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.