Most teams treat AI coding assistants like fancy autocomplete. Tab-completion with a chat interface. I treat them like team members who never sleep, never get sick, and never forget the branching strategy.
The difference? Protocol.
The Problem:
You've got Cursor, Claude Code, or Copilot running. They write code, sure. They generate tests, refactor functions, explain regex. But who handles sprint planning? Who triages incoming issues, estimates story points, coordinates releases, enforces branch strategy? Still you. Still manual. Still context-switching hell.
I watched teams burn cycles on this friction. Smart engineers tabbing between IDE and GitHub, copying issue numbers, manually linking PRs, arguing about commit message format in Slack threads. The AI writes the code, but you herd the process.
The gap isn't intelligence—it's protocol. AI assistants need structured playbooks to actually operate like team members. Without it, they're brilliant interns with no onboarding.
The Solution:
I built agile-workflow as a first-class skill for AI coding assistants. Not a CLI tool you run. Not a SaaS dashboard. A skill your AI knows—embedded protocol it can execute.
Install it once:
npx skills add yabasha/agile-workflow
From that point, your AI assistant becomes your entire agile operation.
What You Can Ask:
The interface is natural language. No flags, no config files, no YAML ceremonies:
> fix all open github issues
> plan the next sprint
> estimate story points for ungroomed issues
> set up conventional commits with husky
> create a release for v2.0.0
> review PR #42
> clean up stale branches
Your AI understands intent, maps to the right protocol phase, executes. You focus on direction, not mechanics.
The Issue Resolution Pipeline:
This isn't cowboy coding. It's a five-phase workflow your AI executes end-to-end:
Phase 1: Discovery & Triage
The AI fetches open issues across your repos. Auto-categorizes by labels using keyword-to-label mapping—"bug" in title lands on the bug label, "performance" tags accordingly. Detects stale issues (30+ days no activity) and surfaces them for priority boost or closure.
Issues get sorted into four priority tiers: Critical, High, Medium, Low. Dependencies are mapped visually—if Issue A blocks Issue B, the AI tracks that. Finally, issues are grouped by file area. Two PRs touching src/auth/ get batched to the same developer queue to avoid merge conflict carnage.
Phase 2: Parallel Development
The AI spawns up to 3–5 parallel developer sessions using isolated git worktrees. Each issue gets its own clean workspace—no branch pollution, no "oops, committed to main" disasters.
Developer prompts include specialty matching. Backend-heavy issue? Assign to the backend specialist configuration. DevOps changes? Route to the ops-aware agent. Each gets context: issue description, acceptance criteria, relevant file paths.
The worktree approach is clean. git worktree add ../feature-branch feature-branch creates an isolated directory your AI can work in independently. When done, it's git worktree remove and gone.
Phase 3: PR Review Management
Human or AI-created PRs both get the same treatment. The AI fetches review comments, classifies them via decision tree: suggestion (nice-to-have), required (blocking), nitpick (style), question (clarification needed).
For required changes, it spawns fix agents on existing branches. Every comment gets a reply with commit reference. Threads are resolved via GitHub's GraphQL API—no orphaned conversations.
The review checklist is standardized: security check, test coverage, breaking change assessment, documentation update verification. Your AI runs the same checklist on every PR, every time.
Phase 4: Dependency-Aware Merge
PRs don't merge randomly. The AI respects dependency order—if PR B depends on PR A, B waits. It handles rebase conflicts automatically when possible, escalating to human review only when the conflict crosses semantic boundaries.
After merge, it verifies all linked issues are actually closed. No "merged PR, forgotten issue" drift.
Phase 5: Cleanup
The AI prunes remote refs, deletes local branches, cleans worktrees. Your repo stays lean. No git branch -a scroll-fests. No "which branches are safe to delete?" Slack polls.
Sprint Planning That Actually Works:
Your AI doesn't just estimate—it explains its math.
The algorithm: count files to change + estimate LOC + dependency factor + test requirement + risk/uncertainty → sum → map to nearest Fibonacci (1, 2, 3, 5, 8, 13, 21).
Five files, moderate LOC, one dependency, needs tests, some uncertainty? That's an 8. Three files, low LOC, no deps, straightforward? That's a 3. The reasoning is transparent, not black-box.
Kanban with WIP Limits:
The AI maintains flow state across columns: Backlog → Ready → In Progress (3 per developer max) → In Review (5 total max) → Done. It enforces limits. Try to start a fourth "In Progress" item and your AI will push back—"Finish #147 first or explain why this jumps the queue."
Definition of Done, Per-Type:
Different work needs different validation. Bugs require reproduction verification. Features need documentation updates. Chores just need CI green. The AI tracks the checklist appropriate to the issue type—no one-size-fits-none approach.
Git Hygiene & Recovery:
Mistakes happen. Force-pushed the wrong branch? git reflog recovery is documented. Detached HEAD state? Step-by-step exit path. Lost a branch? Recovery commands ready.
The skill includes a cheat sheet covering 20+ common git disasters: detached HEAD recovery, force push reversal, lost branch resurrection, stash recovery, merge conflict abort strategies, rebasing gone wrong. Your AI carries the institutional knowledge so you don't have to Stack Overflow at midnight.
Release Management:
Semantic versioning, conventional commits, automated changelogs.
The skill covers 11 conventional commit types: feat, fix, docs, style, refactor, perf, test, build, ci, chore, revert. Commitlint enforcement via Husky hooks means no malformed commits slip through.
Releases follow SemVer strictly. Breaking changes → major. Features → minor. Fixes → patch. Changelogs generate from commit history, categorized by type, linked to PRs and issues.
Monorepo Support:
Changesets handle versioning across packages. Selective CI triggers—only packages with changes run tests. The AI understands workspace boundaries, respects dependency graphs between packages, updates internal references automatically.
Security & Maintenance:
The skill includes Dependabot configuration for automated dependency updates. Gitleaks for secret scanning—catch AWS keys, API tokens, private keys before they hit remote. NPM audit integration flags vulnerabilities in package.json.
GitHub Actions templates cover four scenarios: CI with multi-node version matrices, PR checks with issue reference verification (no "fixes #" in your PR body? blocked), automated release note generation, and weekly dependency update runs (Mondays at 9 AM).
Branch Strategy Decision Tree:
Not every project needs GitFlow. The AI evaluates your release pattern and recommends:
- GitFlow: Scheduled releases, versioning discipline, hotfix lanes
- GitHub Flow: Continuous deployment, small batches, fast feedback
- Trunk-Based: Experienced teams, feature flags, daily merges
It enforces the chosen model. Wrong branch name format? Caught pre-commit. Missing release branch for hotfix? Flagged.
Legacy Support:
Still on SVN? The skill includes reference workflows for SVN-to-Git migration. Your AI can guide the transition, preserve history, set up new remotes, validate the full transfer.
Who It's For:
Teams using Claude Code, Cursor, Windsurf, Copilot, Codex, OpenClaw, Aider—any AI assistant with shell access. Requirements are minimal: git 2.20+, gh CLI 2.0+, and a repository.
This works for solo developers who want AI project management. It works for 20-person teams who need coordination without hiring another PM. It works for agencies juggling client repos.
What's Next:
I'm extending this into multi-agent orchestration. Imagine: three AI developers working the same feature, each handling a vertical—frontend, API, infrastructure—with dependency-aware merging and conflict resolution. The skill layer is the foundation; the orchestration layer is where it gets interesting.
Why This Matters:
AI assistants are only as useful as the protocols you give them. Without structure, they're faster juniors. With structure, they're autonomous team members.
This skill turns "write me a function" into "ship me a feature." It closes the gap between code generation and code delivery.
MIT licensed. Use it, break it, improve it.