AI Skill Report Card
Mapping Human Work to AI Execution
Quick Start14 / 15
Given any human task/skill/workflow, produce a Task Decomposition Map:
TASK: [original human task in plain language]
1. DECOMPOSE → list atomic sub-tasks
2. CLASSIFY → tag each sub-task: [AI-FULL | AI-ASSIST | HUMAN-GATE | HYBRID]
3. MAP → assign inputs/outputs/artifacts per sub-task
4. GATE → insert logic gates (deterministic checks) between steps
5. ACTUATE → define where a human must confirm/approve/inject judgment
6. PACKAGE → output as pipeline (prompt chain, script, workflow spec)
Example one-liner: "Turn my expertise in contract redlining into an AI pipeline" → Decompose into (extract clauses → classify risk → suggest edits → human sign-off) → map each to AI/human/gate.
Recommendation▾
Add a third example covering a more ambiguous/creative domain (e.g., strategic decision-making) to show range beyond process-heavy tasks
Workflow15 / 15
Progress:
- Step 1: Elicit the source — get the human describe the task/skill/workflow in their own words, including edge cases and judgment calls
- Step 2: Decompose into atomic units — break the whole into smallest meaningful actions (not too granular, not too coarse)
- Step 3: Classify each unit by automatability
- Step 4: Identify artifacts — what goes in, what comes out of each unit (data, documents, decisions, files)
- Step 5: Design logic gates — deterministic checkpoints (rules, thresholds, validations) that decide branching/pass-fail
- Step 6: Place human actuation points — where judgment, liability, or ambiguity requires a human
- Step 7: Map resources — datasets, prior research, tools, templates needed at each node
- Step 8: Package into executable form — prompt chain, agent workflow, script, or SOP
- Step 9: Define success metrics — how "done" and "correct" are measured per node and overall
- Step 10: Validate — dry-run against real example, tighten gates/thresholds
Step 2 detail: Decomposition heuristics
- Split by input/output boundary: if output of A feeds directly into B, they're separate nodes
- Split by decision type: pattern-matching (AI-FULL) vs. judgment/risk/ethics (HUMAN-GATE) vs. needs-verification (AI-ASSIST)
- Split by repeatability: if it's done the same way every time, it's automatable; if it varies by context/relationship/politics, it's human
Step 3 detail: Classification tags
| Tag | Meaning | Signal |
|---|---|---|
| AI-FULL | AI executes autonomously | Rule-based, pattern-based, high-volume, low-stakes |
| AI-ASSIST | AI drafts, human edits | Creative/ambiguous output, moderate stakes |
| HUMAN-GATE | Human must approve/decide | Legal, ethical, relational, irreversible, high-stakes |
| HYBRID | Alternates per sub-condition | Depends on data quality, confidence score, exception rate |
Step 5 detail: Logic gate design
Each gate = condition → action. Always deterministic, never vibes-based.
- Confidence gate:
if model_confidence < 0.8 → route to HUMAN-GATE - Validation gate:
if output fails schema/rule check → reject & retry - Volume gate:
if batch_size > N → require sampling review - Risk gate:
if flagged_category in [legal, financial, safety] → force HUMAN-GATE
Recommendation▾
Include a failure-mode example showing a bad decomposition (too granular or misclassified gate) alongside the fix, to reinforce the good/bad contrast
Examples17 / 20
Example 1: Input: "I manually review 200 resumes a week, screening for experience match, then write personalized rejection/interview emails." Output:
1. Parse resume → extract structured fields [AI-FULL]
2. Score against role criteria [AI-FULL, gate: score >= threshold]
3. Borderline cases (score 60-75%) [HUMAN-GATE]
4. Draft interview/rejection email [AI-ASSIST]
5. Final send [HUMAN-GATE: approve batch, or auto-send if AI-ASSIST accuracy >98% over pilot]
Artifacts: resume PDFs → structured JSON → scored table → draft emails → sent emails
Gate: score<40 auto-reject-email; 40-75 human review; >75 auto-interview-invite
Metric: false-reject rate, human review time saved
Example 2: Input: "I do freelance video editing — cutting raw footage down to highlight reels." Output:
1. Ingest raw footage, transcribe audio [AI-FULL]
2. Detect scene/highlight candidates (motion, audio peaks, keyword hits) [AI-FULL]
3. Rank/select top N clips [AI-ASSIST]
4. Human curates final clip order & pacing [HUMAN-GATE]
5. Auto-generate rough cut with transitions [AI-FULL]
6. Human final polish & color/audio pass [HUMAN-GATE]
7. Export/deliver [AI-FULL]
Gate: if highlight-detection confidence < 0.6 → flag clip for manual review
Metric: % of AI-selected clips kept by editor unmodified (proxy for automation maturity)
Recommendation▾
Provide a minimal output template/schema block that could be copy-pasted for the 'PACKAGE' step (e.g., YAML or JSON pipeline spec) rather than only prose-style examples
Best Practices
- Start from the artifact, not the activity. Ask "what physical/digital thing gets produced at each step?" — easier to map than abstract "skills."
- Push human-gates toward exceptions, not defaults. Default path should be AI-FULL/AI-ASSIST; humans handle the tail, not the bulk.
- Make every gate a testable condition, not "use judgment." If you can't write it as an if/then, it's not a gate yet — it's still a human task.
- Version the pipeline. As AI-ASSIST nodes prove reliable (tracked via metrics), promote them to AI-FULL with a gate for drift/anomaly detection.
- Preserve provenance. Tag every artifact with which node produced it, so failures can be traced back to a specific sub-task.
- Reuse existing datasets/templates as scaffolding before generating new ones — map first, generate only for gaps.
Common Pitfalls
- Automating the whole task in one shot instead of decomposing — produces a black box that can't be debugged or trusted.
- Placing human-gates based on discomfort rather than actual stakes/irreversibility — wastes human time on low-risk steps.
- Vague gates like "AI checks if it looks right" — not deterministic, will drift and fail silently.
- Ignoring artifact format mismatches between steps (e.g., AI outputs prose where next step needs structured data) — always specify exact schema at each handoff.
- Treating the first mapped pipeline as final — it's a draft; validate against real runs and tighten thresholds.