worktracker
This skill should be used when the user asks to "create work item", "track task", "list tasks", "update work status", or mentions work/task management.
Best use case
worktracker is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
This skill should be used when the user asks to "create work item", "track task", "list tasks", "update work status", or mentions work/task management.
Teams using worktracker should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/worktracker/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How worktracker Compares
| Feature / Agent | worktracker | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
This skill should be used when the user asks to "create work item", "track task", "list tasks", "update work status", or mentions work/task management.
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
SKILL.md Source
# Work Tracker Skill
> Local Azure DevOps/JIRA alternative for surviving context rot in long-running sessions.
---
## Purpose
The Work Tracker skill provides persistent task management that survives context
compaction, session boundaries, and context rot. It serves as the "external memory"
for tracking what needs to be done, what's in progress, and what's completed.
### The Context Rot Problem
> "Context Rot is the phenomenon where an LLM's performance degrades as the context
> window fills up, even when total token count is well within the technical limit."
> — [Chroma Research](https://research.trychroma.com/context-rot)
Work Tracker mitigates this by:
- **Persisting state to filesystem** - Not dependent on context window
- **Providing compact summaries** - Load only what's needed
- **Enabling session continuity** - Pick up where you left off
---
## Commands
### Create Work Item
Create a new work item for tracking.
```
@worktracker create <title> [--type TYPE] [--priority PRIORITY] [--parent PARENT_ID]
```
**Arguments:**
- `title`: Short description of the work (required)
- `--type`: `feature`, `bug`, `task`, `spike`, `epic` (default: `task`)
- `--priority`: `critical`, `high`, `medium`, `low` (default: `medium`)
- `--parent`: Parent work item ID for hierarchy
**Example:**
```
@worktracker create "Implement user authentication" --type feature --priority high
```
**Output:**
```
Created: WORK-001 "Implement user authentication"
Type: feature | Priority: high | Status: pending
```
---
### List Work Items
List work items with optional filters.
```
@worktracker list [--status STATUS] [--type TYPE] [--priority PRIORITY] [--limit N]
```
**Arguments:**
- `--status`: `pending`, `in_progress`, `blocked`, `completed`, `all` (default: `pending,in_progress`)
- `--type`: Filter by type
- `--priority`: Filter by priority
- `--limit`: Maximum items to return (default: 20)
**Example:**
```
@worktracker list --status in_progress
```
**Output:**
```
Work Items (in_progress):
┌────────────┬──────────────────────────────┬──────────┬──────────┐
│ ID │ Title │ Priority │ Type │
├────────────┼──────────────────────────────┼──────────┼──────────┤
│ WORK-001 │ Implement user authentication│ high │ feature │
│ WORK-003 │ Fix login redirect bug │ critical │ bug │
└────────────┴──────────────────────────────┴──────────┴──────────┘
```
---
### Update Work Item
Update a work item's properties.
```
@worktracker update <id> [--status STATUS] [--priority PRIORITY] [--title TITLE] [--notes NOTES]
```
**Arguments:**
- `id`: Work item ID (required)
- `--status`: New status
- `--priority`: New priority
- `--title`: New title
- `--notes`: Add notes to the work item
**Example:**
```
@worktracker update WORK-001 --status in_progress --notes "Started implementation, defining domain entities"
```
**Output:**
```
Updated: WORK-001
Status: pending → in_progress
Notes added: "Started implementation, defining domain entities"
```
---
### Complete Work Item
Mark a work item as completed.
```
@worktracker complete <id> [--notes NOTES]
```
**Arguments:**
- `id`: Work item ID (required)
- `--notes`: Completion notes
**Example:**
```
@worktracker complete WORK-001 --notes "Implemented with JWT tokens, tests passing"
```
**Output:**
```
Completed: WORK-001 "Implement user authentication"
Duration: 2h 15m
Notes: "Implemented with JWT tokens, tests passing"
```
---
### Show Work Item Details
Show full details of a work item.
```
@worktracker show <id>
```
**Example:**
```
@worktracker show WORK-001
```
**Output:**
```
WORK-001: Implement user authentication
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Type: feature
Status: completed
Priority: high
Created: 2026-01-07 10:30:00
Completed: 2026-01-07 12:45:00
Duration: 2h 15m
Description:
Add JWT-based authentication to the API layer.
Notes:
[2026-01-07 10:35] Started implementation, defining domain entities
[2026-01-07 11:20] Domain layer complete, moving to infrastructure
[2026-01-07 12:45] Implemented with JWT tokens, tests passing
Children:
WORK-002: Create User entity (completed)
WORK-003: Implement JWT adapter (completed)
References:
- docs/design/AUTH_DESIGN.md
- src/domain/aggregates/user.py
```
---
### Search Work Items
Search work items by text.
```
@worktracker search <query> [--include-completed]
```
**Arguments:**
- `query`: Search text (searches title, description, notes)
- `--include-completed`: Include completed items in search
**Example:**
```
@worktracker search "authentication"
```
---
### Session Summary
Get a summary for the current session context.
```
@worktracker summary [--since DURATION]
```
**Arguments:**
- `--since`: Time window (`1h`, `1d`, `1w`) (default: current session)
**Example:**
```
@worktracker summary --since 1d
```
**Output:**
```
Work Tracker Summary (last 24h)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Completed: 5 items
- WORK-001: Implement user authentication
- WORK-002: Create User entity
- ...
In Progress: 2 items
- WORK-006: Add rate limiting [high]
- WORK-007: Write API documentation [medium]
Blocked: 1 item
- WORK-008: Deploy to staging (waiting on infra)
Pending: 12 items (3 high priority)
Recommended Next:
→ WORK-006: Add rate limiting (high priority, in progress)
```
---
## Data Model
### Work Item Properties
| Property | Type | Description |
|----------|------|-------------|
| `id` | string | Unique identifier (WORK-NNN) |
| `title` | string | Short description |
| `description` | string | Detailed description |
| `type` | enum | feature, bug, task, spike, epic |
| `status` | enum | pending, in_progress, blocked, completed |
| `priority` | enum | critical, high, medium, low |
| `parent_id` | string | Parent work item ID |
| `created_at` | datetime | Creation timestamp |
| `updated_at` | datetime | Last update timestamp |
| `completed_at` | datetime | Completion timestamp |
| `notes` | list | Timestamped notes |
| `references` | list | Related files/docs |
| `tags` | list | Custom tags |
### Storage
Work items are stored in the active project's `.jerry/data/` directory:
```
projects/${JERRY_PROJECT}/.jerry/data/
├── items/
│ └── WORK-NNN.json # Individual work item files
├── index.json # Quick lookup index
└── sequences.json # ID sequence tracking
```
> **Note**: `JERRY_PROJECT` environment variable must be set to identify the active project.
> If not set, the skill will prompt you to specify which project to use.
---
## Integration
### With TodoWrite Tool
Work Tracker complements the built-in TodoWrite tool:
- **TodoWrite**: Ephemeral, in-session task tracking
- **Work Tracker**: Persistent, cross-session work items
Sync pattern:
```
@worktracker sync-from-todo # Import current todos as work items
@worktracker sync-to-todo # Export work items to todos
```
### With PLAN Files
Work items can reference PLAN files:
```
@worktracker create "Implement caching layer" --plan docs/plans/PLAN_caching.md
```
### With Commits
Work items can be linked to commits:
```
git commit -m "feat(auth): implement JWT tokens
Closes: WORK-001, WORK-002"
```
---
## Execution
### CLI Interface (v0.1.0)
The `jerry items` CLI namespace provides work item management:
```bash
# List work items
jerry items list [--status STATUS] [--type TYPE]
# Show work item details
jerry items show <id>
# Create work item (Phase 4.5 - deferred for Event Sourcing)
jerry items create <title> [--type TYPE]
# Start/complete work (Phase 4.5 - deferred)
jerry items start <id>
jerry items complete <id>
```
**JSON Output**: Add `--json` for scripting/AI consumption:
```bash
jerry --json items list
jerry --json items show WORK-001
```
### Skill Interface
The skill interface translates natural language to CLI commands:
| Skill Command | Maps To |
|--------------|---------|
| `@worktracker list` | `jerry items list` |
| `@worktracker show <id>` | `jerry items show <id>` |
| `@worktracker create <title>` | `jerry items create <title>` |
The skill routes to:
- `src/application/handlers/queries/` for reads (via QueryDispatcher)
- `src/application/handlers/commands/` for mutations (Phase 4.5)
---
## Best Practices
1. **Create work items before starting work** - Establishes tracking
2. **Update status promptly** - Accurate state for context reload
3. **Add notes during work** - Captures context for later
4. **Use hierarchy for complex tasks** - Epics → Features → Tasks
5. **Link references** - Connect to files, docs, commits
6. **Run summary at session start** - Orient to current stateRelated Skills
worktracker-decomposition
This skill should be used when the user asks to "decompose task", "break down work", "create subtasks", or mentions task breakdown.
ux-lean-ux
Lean UX hypothesis-driven design sub-skill for the /user-experience parent skill. Facilitates Build-Measure-Learn cycles using Jeff Gothelf and Josh Seiden's Lean UX methodology (3rd ed. 2021). Produces hypothesis backlogs, assumption maps, MVP experiment designs, and validated learning logs. Invoke when teams need hypothesis-driven iteration, assumption mapping, experiment design, or validated learning documentation. Invoked by ux-orchestrator during Wave 2 lifecycle-stage routing or when user intent is "testing hypotheses" during the "During design" stage. Triggers: lean UX, hypothesis, assumption mapping, build-measure-learn, MVP experiment, validated learning, experiment design, hypothesis backlog.
ux-kano-model
Kano model feature classification and prioritization sub-skill for the /user-experience parent skill. Classifies product features into Must-be (M), Performance (O), Attractive (A), Indifferent (I), and Reverse (R) categories using the functional/dysfunctional questionnaire pair methodology (Kano et al., 1984). Computes Customer Satisfaction (CS) coefficients (Better/Worse) for priority matrix visualization. Produces feature classification reports, priority matrices, and survey design templates. Sample size awareness: 5-8 respondents yields directional classification only (MEDIUM confidence); 20+ respondents required for statistical classification (Berger et al., 1993). Invoked by ux-orchestrator during Wave 4 lifecycle-stage routing or when user intent is "Need to prioritize features" at any lifecycle stage. Triggers: Kano, must-be, attractive, one-dimensional, performance feature, satisfaction, feature classification, delighter, feature prioritization, CS coefficient.
ux-jtbd
Jobs-to-Be-Done research and analysis sub-skill for the /user-experience parent skill. Conducts JTBD job statement synthesis, switch interview analysis (Moesta/Spiek four forces), outcome-driven innovation (Ulwick ODI), and job mapping for tiny teams (1-5 people). Invoked by ux-orchestrator when users need to understand user motivations, map jobs to be done, identify switch triggers, or produce job maps with outcome expectations. Sub-skill of /user-experience; routed via ux-orchestrator lifecycle-stage triage. Triggers: JTBD, jobs to be done, switch interview, job mapping, user motivation, outcome, hiring criteria, user jobs, switch forces.
ux-inclusive-design
Inclusive design and WCAG 2.2 accessibility evaluation sub-skill for the /user-experience parent skill. Performs WCAG 2.2 compliance audits across Perceivable, Operable, Understandable, and Robust principles (conformance levels A, AA, AAA) and applies Microsoft Inclusive Design methodology including Persona Spectrum analysis (permanent, temporary, situational disabilities). Produces accessibility audit reports and persona spectrum analyses. Invoke when teams need accessibility compliance evaluation, WCAG conformance auditing, screen reader compatibility assessment, color contrast analysis, cognitive load evaluation, or inclusive design review. Invoked by ux-orchestrator during Wave 3 lifecycle-stage routing or when user intent is "Check accessibility" at any lifecycle stage. Triggers: accessibility, WCAG, ARIA, screen reader, contrast, cognitive load, inclusive, a11y, inclusive design, WCAG 2.2, persona spectrum.
ux-heuristic-eval
Nielsen heuristic evaluation sub-skill for the /user-experience parent skill. Evaluates interfaces against Nielsen's 10 usability heuristics, produces severity-rated findings on a 0-4 scale (Cosmetic to Catastrophic), and generates remediation recommendations with effort estimates. Invoke when teams need structured usability evaluation, interface review, heuristic audit, or severity-rated UX findings. Invoked by ux-orchestrator during Wave 1 lifecycle-stage routing or CRISIS mode triage. Triggers: heuristic evaluation, usability audit, Nielsen heuristics, interface review, severity rating, usability inspection, UX evaluation.
ux-heart-metrics
HEART Metrics framework sub-skill for the /user-experience parent skill. Applies Google's HEART framework (Happiness, Engagement, Adoption, Retention, Task Success) using the Goals-Signals-Metrics (GSM) process to define measurable UX metrics for products and features. Invoked by ux-orchestrator when users need to measure UX health, define UX metrics, establish measurement baselines, or produce dashboard-ready metric specifications. Sub-skill of /user-experience; routed via ux-orchestrator lifecycle-stage triage. Triggers: HEART, metrics, happiness, engagement, adoption, retention, task success, GSM, measurement, UX metrics, dashboard, goals signals metrics.
ux-design-sprint
AJ&Smart Design Sprint 2.0 facilitation sub-skill for the /user-experience parent skill. Facilitates a structured four-day rapid prototyping and validation process compressed from the Google Ventures five-day Design Sprint (Knapp, Zeratsky & Kowitz, 2016; Courtney, 2019). Produces sprint artifacts including challenge maps, solution sketches, storyboards, realistic prototypes, and structured user interview findings with synthesis confidence gates. Invoke when teams need to rapidly validate a product concept, solve a critical design challenge through structured prototyping, test ideas with real users before committing to development, or explore solution directions when they do not know what to build. Triggers: design sprint, GV sprint, rapid prototyping, sprint week, map sketch decide test, 4-day sprint, design sprint 2.0, AJ Smart sprint, validate prototype, test with users, sprint facilitation.
ux-behavior-design
Fogg Behavior Model B=MAP bottleneck diagnosis sub-skill for the /user-experience parent skill. Diagnoses why users fail to take desired actions by analyzing the three B=MAP factors (Motivation, Ability, Prompt) and identifying which factor falls below the action threshold. Produces bottleneck diagnoses, factor-level assessments, and intervention recommendations with synthesis confidence gates. Invoke when teams need to understand why users are not completing a specific action, diagnose behavioral bottlenecks, design behavior change interventions, or analyze post-launch user inaction patterns. Invoked by ux-orchestrator during Wave 4 lifecycle-stage routing or when user intent is "Users not completing action" during the "After launch" stage. Triggers: behavior design, B=MAP, Fogg model, behavior bottleneck, motivation analysis, ability analysis, prompt design, why users don't, user inaction, behavior diagnosis, tiny habits, action threshold.
ux-atomic-design
Atomic Design component taxonomy sub-skill for the /user-experience parent skill. Implements Brad Frost's 5-level component hierarchy (Atoms, Molecules, Organisms, Templates, Pages) for design system architecture. Produces component inventories, design token audits, composition rules, and Storybook coverage reports. Invoke when teams need component taxonomy construction, design system architecture, Storybook integration, design token consistency analysis, or component reuse auditing. Invoked by ux-orchestrator during Wave 3 lifecycle-stage routing or when user intent is "Building component system" during the "During design" stage. Triggers: atomic design, component taxonomy, design tokens, Storybook, atoms molecules organisms, design system, component inventory, component library.
ux-ai-first-design
AI-first interaction design sub-skill (CONDITIONAL) for the /user-experience parent skill. Provides trust-calibrated AI interaction design guidance using Yang et al.'s trust-risk and error-risk classification framework. Produces interaction pattern recommendations, trust calibration assessments, feedback loop designs, and progressive disclosure strategies for AI-powered features. CONDITIONAL: requires WSM >= 7.80 AND enabler research (FEAT-020) complete; otherwise routes to /ux-heuristic-eval with PAIR protocol. Invoke when teams need to design AI-powered interactions, calibrate user trust in AI outputs, classify AI error risks, design human-AI handoff patterns, or audit existing AI interfaces for trust and safety. Triggers: AI-first design, AI interaction, trust calibration, AI UX, conversational UX, AI interface, LLM interface, agentic UX, human-AI interaction, AI transparency, AI error handling, AI onboarding, progressive AI disclosure, trust-risk, error-risk.
user-experience
Parent orchestrator for AI-augmented UX methodology targeting tiny teams (1-5 people). Routes to 10 sub-skills by product lifecycle stage through criteria-gated waves. Invoke when team needs structured UX evaluation, user research, design systems, UX metrics, behavior diagnosis, feature prioritization, design sprints, or AI interaction design. Each sub-skill implements a proven UX framework with synthesis hypothesis confidence gates and MCP design tool integration. Triggers: UX, user experience, usability, heuristic evaluation, JTBD, lean UX, HEART metrics, atomic design, inclusive design, behavior design, Kano model, design sprint, AI-first design, UX audit, accessibility, design system, user research.