A set of agents, skills, and instructions for GitHub Copilot and other AI coding agents to run structured, PRD-driven development workflows. Inspired by snarktank/ai-dev-tasks.

This system brings structure and clarity to AI-assisted development by:

• Defining scope with Product Requirements Documents (PRDs)
• Breaking requirements into actionable, implementation-ready tasks
• Guiding the AI to tackle one task at a time with checkpoints for review
• Providing specialized agents that orchestrate the workflow end-to-end
• Enforcing documentation, branch discipline, and GitHub-as-source-of-truth

Key distinctions:

• Skills save context window space — they are loaded only when invoked, unlike instructions which are always present.
• Agent files define who (identity, phases, handoff rules). Skill files define how (procedures, templates, steps).
• Instructions are for cross-cutting rules that must never be forgotten (e.g., implementation discipline, planning format).

• macOS / Linux (or WSL on Windows)
• git
• curl
• tar
• shasum (or sha256sum)

Run this in the repository where you want to use the workflow:

curl -fsSL https://raw.githubusercontent.com/llipe/dev-tasks/main/dev-tasks.sh \
  -o dev-tasks.sh && chmod +x dev-tasks.sh
./dev-tasks.sh install

git clone https://github.com/llipe/dev-tasks.git
cd dev-tasks
chmod +x dev-tasks.sh
./dev-tasks.sh version
./dev-tasks.sh check

After install, confirm these paths exist in your target repo:

• .github/agents/
• .github/skills/
• .github/instructions/
• .github/prompts/
• .dev-tasks-version

Bootstrap from any repository with one command:

curl -fsSL https://raw.githubusercontent.com/llipe/dev-tasks/main/dev-tasks.sh \
  -o dev-tasks.sh && chmod +x dev-tasks.sh
./dev-tasks.sh install

This downloads the latest versioned bundle from GitHub Releases, places all managed files in .github/agents/, .github/skills/, .github/instructions/, and .github/prompts/, writes .dev-tasks-version for traceability, and prints an AGENTS.md integration prompt showing what changed.

Pin to a specific version:

./dev-tasks.sh install v1.2.0

Check for updates:

./dev-tasks.sh check

List installed files and directories:

./dev-tasks.sh list

Update (with automatic backup):

./dev-tasks.sh update --backup

Preview what would change without writing any files:

./dev-tasks.sh update --dry-run

See Distribution & Script Reference below for full documentation.

After install, your repo contains:

your-repo/
├── dev-tasks.sh               # Keep this — used for future updates
├── .dev-tasks-version         # Installed version metadata (JSON)
├── .github/
│   ├── instructions/          # Always-loaded rules
│   │   ├── plan.instructions.md
│   │   ├── implement.instructions.md
│   │   └── domain/
│   │       └── nextjs-pages-components.instructions.md
│   ├── agents/                # Agent definitions (8 agents)
│   ├── skills/                # On-demand capabilities (12 skills)
│   └── prompts/               # Ready-to-use prompt templates
├── docs/                      # Foundation docs (generated by init)
├── workstream/                # Active feature work
└── AGENTS.md                  # Master registry (you own this — see integration prompt)

Run the product-engineer agent in Init Mode to establish your product context and technical guidelines:

Use the product-engineer-init prompt or invoke @product-engineer with a project description.

This produces docs/product-context.md and docs/technical-guidelines.md. Run this once per project (or when a major pivot occurs).

Create technology-specific instruction files scoped to certain file patterns via applyTo frontmatter:

---
applyTo: "apps/my-app/src/**/*.tsx"
---
# Your project-specific component conventions here

Agents are autonomous personas that orchestrate skills and activities. They live in .github/agents/.

Preparation agent — owns the full pre-coding chain:

• Init Mode: activity-init → product-context.md + technical-guidelines.md
• Feature Mode: activity-refine → activity-generate-spec → activity-generate-stories → activity-publish-github → plan
• Issue Mode: activity-refine → plan

Hands off to developer or planner for execution.

Execution agent — implements code from an existing task list. Runs implement only. Uses git-ops for branch management.

Multi-story orchestration with checkpoint/resume:

On-demand capabilities loaded only when invoked. Each lives in .github/skills/<name>/SKILL.md.

product-engineer: refine → generate-spec → generate-stories → publish-github → plan
                                                                                  ↓
developer: implement

product-engineer: refine → plan
                            ↓
developer: implement

product-engineer: ... → plan
                          ↓
planner: orchestrate → developer: implement (per story, sequential)

developer: implement

product-engineer: refine → generate-spec → ux-engineer: mockups → product-engineer: update

product-engineer: refine → spec → stories → plan
                                                 ↓
black-box-tester: generate test plan (from spec or stories)
                                                 ↓
developer: implement (feature + tests from test plan)
                                                 ↓
black-box-tester: validate compliance → validation report

• Use step-gated mode (default) to review each sub-task
• Use pre-approved autonomous batch mode when you trust the agent to run autonomously
• Use planner-resume when a multi-story orchestration is interrupted
• Run housekeeping after major feature branches to catch regressions
• Domain instructions are auto-applied based on applyTo patterns

When memo-cli is installed and configured, this workflow supports shared context across sessions, agents, and repositories.

• product-engineer reads context from memo at session start and before major design choices.
• developer writes an intent entry before story implementation and an outcome entry after completion.
• technical-writer writes one memo entry per ADR and per significant technical documentation change.

Recommended startup check:

which memo && memo setup validate

If memo is installed but validation fails, configure the repo first:

memo setup init --repo <repo-name> --org <org-name> --domain <domain>

Use --scope related for cross-repo context when relates_to is configured in memo.config.json.

Use the repo-local formatter wrapper for tracked Markdown, JSON, and YAML files:

./scripts/format.sh --check
./scripts/format.sh --write

The script uses prettier from your PATH when available and falls back to npx --yes prettier otherwise.

The toolkit is distributed as a versioned tarball via GitHub Releases. dev-tasks.sh is the single installer/updater — no runtime beyond standard POSIX tools (curl, tar, shasum) is required.

The script owns these paths and may overwrite them on update:

Never touched by the script: AGENTS.md — the script prints an integration prompt instead (see below).

After every install or update, the script prints a === AGENTS.md Integration === block showing the diff between the bundled reference AGENTS.md and your local copy. It also saves the reference to .dev-tasks-agents-update.md. The script never silently overwrites your AGENTS.md — you decide what to merge.

# Pin to a specific version
./dev-tasks.sh install v0.1.3

# Update with backup so you can roll back manually
./dev-tasks.sh update --backup

# Roll back: restore from backup
cp -r .dev-tasks-backup/<timestamp>/. ./

.dev-tasks-version is written after every install/update:

{
  "version": "1.2.0",
  "installed_at": "2026-04-20T12:00:00Z",
  "script_version": "1.0.0",
  "source": "https://github.com/llipe/dev-tasks"
}

Every git tag matching v*.*.* triggers .github/workflows/release-bundle.yml, which:

1. Runs scripts/build-bundle.sh to package managed files into dev-tasks-bundle-v<version>.tar.gz
2. Generates a SHA256 checksum
3. Runs a smoke test against the bundle
4. Creates the GitHub Release and attaches the bundle + checksum as assets

1. Ensure the release changes are merged into main.
2. Sync your local branch:

git checkout main
git pull origin main

3. Create and push a semantic version tag (vMAJOR.MINOR.PATCH):

git tag -a v1.3.0 -m "Release v1.3.0"
git push origin v1.3.0

4. Wait for .github/workflows/release-bundle.yml to complete.
5. Verify the GitHub Release contains both assets:

• dev-tasks-bundle-v1.3.0.tar.gz
• dev-tasks-bundle-v1.3.0.tar.gz.sha256

Optional post-release validation:

./dev-tasks.sh install v1.3.0

If you prefer manual installation, download the bundle and checksum from:

• https://github.com/llipe/dev-tasks/releases

Example for a specific version:

VERSION=v1.3.0
BASE_URL="https://github.com/llipe/dev-tasks/releases/download/${VERSION}"

curl -fL -o "dev-tasks-bundle-${VERSION}.tar.gz" \
  "${BASE_URL}/dev-tasks-bundle-${VERSION}.tar.gz"
curl -fL -o "dev-tasks-bundle-${VERSION}.tar.gz.sha256" \
  "${BASE_URL}/dev-tasks-bundle-${VERSION}.tar.gz.sha256"

# Verify checksum
shasum -a 256 -c "dev-tasks-bundle-${VERSION}.tar.gz.sha256"

# Extract
tar -xzf "dev-tasks-bundle-${VERSION}.tar.gz"

Original idea based on snarktank/ai-dev-tasks