~aod-status
On-demand backlog snapshot and lifecycle stage summary. Regenerates BACKLOG.md from GitHub Issues and displays item counts per stage. Use this skill when you need to check backlog status, view stage counts, regenerate BACKLOG.md, or get a lifecycle overview.
Best use case
~aod-status is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
On-demand backlog snapshot and lifecycle stage summary. Regenerates BACKLOG.md from GitHub Issues and displays item counts per stage. Use this skill when you need to check backlog status, view stage counts, regenerate BACKLOG.md, or get a lifecycle overview.
Teams using ~aod-status 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/~aod-status/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How ~aod-status Compares
| Feature / Agent | ~aod-status | 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?
On-demand backlog snapshot and lifecycle stage summary. Regenerates BACKLOG.md from GitHub Issues and displays item counts per stage. Use this skill when you need to check backlog status, view stage counts, regenerate BACKLOG.md, or get a lifecycle overview.
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
# AOD Status Skill
## Purpose
Utility skill for the AOD Lifecycle. Provides an on-demand snapshot of the project backlog by regenerating BACKLOG.md from GitHub Issues and displaying a summary of items per lifecycle stage.
No governance gates — this is a read-only utility command.
## How It Works
### Step 1: Reconcile Board
Run board reconciliation to fix any label↔board column drift before generating the snapshot:
```bash
source .aod/scripts/bash/github-lifecycle.sh && aod_gh_reconcile_board
```
This compares each open issue's `stage:*` label to its board column and fixes mismatches. If the board or `gh` is unavailable, it skips silently.
### Step 2: Regenerate BACKLOG.md
Run the backlog regeneration script with JSON output mode:
```bash
bash .aod/scripts/bash/backlog-regenerate.sh --json
```
**Parse the JSON output** to extract:
- `file`: path to regenerated BACKLOG.md
- `total`: total number of GitHub Issues
- `stages`: object with counts per stage (`discover`, `define`, `plan`, `build`, `deliver`, `untracked`)
**If the script fails or `gh` is unavailable**: Display a warning and attempt to read the existing BACKLOG.md file instead. If no BACKLOG.md exists either, report that no backlog data is available.
### Step 3: Display Stage Summary
Present a formatted summary table:
```
AOD LIFECYCLE STATUS
| Stage | Count |
|----------|-------|
| Discover | {n} |
| Define | {n} |
| Plan | {n} |
| Build | {n} |
| Deliver | {n} |
| Untracked| {n} |
|----------|-------|
| Total | {n} |
BACKLOG.md regenerated at {file_path}.
```
### Step 4: Show Active Feature Context (Optional)
If the current git branch matches a feature pattern (`NNN-*`), display the active feature context:
1. Get branch: `git branch --show-current`
2. Extract NNN prefix
3. Check for `specs/{NNN}-*/` directory
4. If found, read spec.md/plan.md/tasks.md frontmatter to show approval status:
```
Active Feature: {NNN}-{name}
spec.md: {PM approved / not approved / missing}
plan.md: {dual approved / not approved / missing}
tasks.md: {triple approved / not approved / missing}
```
If not on a feature branch, skip this section.
## Edge Cases
- **`gh` CLI unavailable**: Warn and fall back to reading existing BACKLOG.md (may be stale)
- **No GitHub remote**: Same as above — graceful degradation
- **Empty backlog**: Display the table with all zeros
- **Script not found**: Warn: "backlog-regenerate.sh not found at expected path"
- **Not on a feature branch**: Skip active feature context section
## Integration
### Reads
- `.aod/scripts/bash/github-lifecycle.sh` — reconciliation functions
- `.aod/scripts/bash/backlog-regenerate.sh` — regeneration script (JSON mode)
- `docs/product/_backlog/BACKLOG.md` — fallback if script fails
- `specs/{NNN}-*/spec.md`, `plan.md`, `tasks.md` — active feature context
### Invokes
- `aod_gh_reconcile_board` — fixes label↔board drift before snapshot
### Updates
- `docs/product/_backlog/BACKLOG.md` — regenerated from GitHub Issues
- GitHub Projects board — reconciles mismatched columnsRelated Skills
~aod-spec
Validates specification completeness and quality by checking for mandatory sections, [NEEDS CLARIFICATION] markers, testable criteria, and clear scope boundaries. Use this skill when you need to check if spec is complete, validate specifications, review spec.md, or check specification quality. Ensures specifications are ready for architecture and implementation phases.
~aod-score
Re-score an existing idea's ICE rating when circumstances change. Use this skill when you need to re-evaluate ideas, update ICE scores, change idea priority, or re-assess deferred ideas.
~aod-run
Full lifecycle orchestrator that chains all 6 AOD stages (Discover, Define, Plan, Build, Deliver, Document) with disk-persisted state for session resilience and governance gates at every boundary. Use this skill when you need to run the full lifecycle, orchestrate stages, resume orchestration, or check orchestration status.
~aod-project-plan
Validates architecture documentation completeness by checking for technology stack, API specifications, database schema, security architecture, and alignment with feature specification. Use this skill when you need to check if plan.md is complete before implementation, validate architecture documentation, or review technical plans for completeness.
~aod-plan
Plan stage orchestrator that runs all three Plan sub-steps (spec → project-plan → tasks) in sequence with governance gates. Stops on rejection, continues through approvals. Use this skill when you need to run the full Plan stage, navigate planning sub-steps, or resume after a rejection.
~aod-kickstart
POC kickstart skill that transforms a project idea into a sequenced consumer guide with 6-10 seed features. Use when a developer invokes /aod.kickstart to generate a consumer guide, when starting a new project and needing a structured backlog plan, or when converting a project idea into seed features for the AOD lifecycle. Three-stage workflow: Idea Intake, Stack Selection, Guide Generation.
~aod-discover
Unified discovery skill with 4 entry points: /aod.discover (full flow: capture + score + validate), /aod.discover --seed (fast-track pre-vetted ideas with auto defaults), /aod.idea (capture + score only), /aod.validate (PM validation for existing idea). Use this skill when you need to capture ideas, run discovery, validate ideas with PM, generate user stories, log feature requests, or add items to the ideas backlog.
~aod-deliver
Structured delivery retrospective for the AOD Lifecycle's Deliver stage. Validates Definition of Done, captures delivery metrics (estimated vs. actual duration), logs surprises, feeds new ideas back into discovery via GitHub Issues, and creates Institutional Knowledge entries. Use this skill when you need to close a feature, run a delivery retrospective, capture lessons learned, or complete the AOD lifecycle.
~aod-define
Internal skill invoked by /aod.define to generate industry-standard PRD content using proven frameworks from Google, Amazon, and Intercom. Do NOT invoke directly — use /aod.define instead, which wraps this skill with Triad governance and sign-offs.
~aod-build
Generate standardized checkpoint reports for multi-phase implementation projects. Use this skill when pausing implementation at strategic milestones (phase completion, user story completion, critical features) to create comprehensive progress reports with task breakdowns, metrics, knowledge base entries, and resume instructions.
~aod-bugfix
One-shot governed bug fix loop: diagnose → plan → implement → verify → document. TRIGGER when: user reports a bug, pastes an error message/stack trace/failing test, or asks to fix a bug. Runs 5 Whys root cause analysis, presents confirmation gate before any code changes, implements fix, verifies with tests, and generates KB entry for review.
~aod-blueprint
Unified project setup and story generation skill that auto-detects new vs existing projects. Three modes: first-run (creates repo, registers project, activates), subsequent-run (skips setup, adds new stories with deduplication), and demo (loads pre-built Hello World stories). Generates ICE-scored, dependency-ordered stories as GitHub Issues and outputs a consumer guide. Use when a developer invokes /aod.blueprint to bootstrap or extend a project.