/quick-dev

name: quick-dev
description: Quick Task workflow — skip Idea→Proposal, create tasks directly, execute, and verify.
license: AGPL-3.0
metadata:
  author: chorus
  version: "0.24.0"
  category: project-management
  mcp_server: chorus

Quick Dev Skill

Skip the full AI-DLC pipeline (Idea → Elaboration → Proposal → Approval) and create tasks directly. Ideal for small, well-understood work. The goal is for agents to **autonomously record their development work and verify task completion** through structured acceptance criteria.

---

Overview

The standard AI-DLC flow ensures quality through structured planning, but adds overhead that slows down small tasks. Quick Dev provides a lightweight alternative:

check explicit task:admin permission → create/claim → implement → self-check AC → submit → independent task review → verify or hand off

**Use Quick Dev when:**

• Bug fixes with clear reproduction steps
• Small features (< 2 story points)
• Post-delivery patches and gap-filling after a proposal's tasks are done
• Prototype or exploratory tasks
• Urgent hotfixes that can't wait for proposal review

**Do NOT use Quick Dev when:**

• The feature needs a PRD or tech design document
• Multiple interdependent tasks require upfront planning
• Stakeholder elaboration is needed to clarify requirements
• The work impacts architecture or shared components significantly

For complex work, use `/idea` + `/proposal` instead.

---

Pre-Flight: Permission Check

Call `chorus_checkin` and inspect the active agent's effective permissions. Set `canVerifyTask` to true **only** when `chorus_checkin().agent.permissions.task` explicitly contains `"admin"` (the `task:admin` permission).

Never infer verification authority from the agent's name, persona, preset/role label, task ownership, or tool availability. Do not ask whether to self-verify: the explicit permission determines the terminal path.

---

Tools

| Tool | Purpose | |------|---------| | `chorus_create_tasks` | Create task(s) — omit `proposalUuid` for standalone Quick Task (optionally linked to an Idea via top-level `ideaUuid`), or pass it to attach to an existing proposal | | `chorus_update_task` | Edit task fields (title, description, priority, AC, dependencies, `ideaUuid` link) or change status | | `chorus_claim_task` | Claim a task (open → assigned) | | `chorus_report_work` | Report progress with optional status update | | `chorus_report_criteria_self_check` | Self-check acceptance criteria before submitting | | `chorus_submit_for_verify` | Submit for admin verification | | `chorus_admin_verify_task` | **(admin only)** Verify task — use when self-verification is approved |

---

Workflow

Step 1: Create a Quick Task

**`acceptanceCriteriaItems` is required** — `chorus_create_tasks` rejects any task without at least one non-blank criterion (and rejects the whole batch if any task is missing them). These are also the foundation for self-checking in Step 6. Write specific, testable criteria that you can objectively verify after development. Vague AC like "works correctly" defeats the purpose; prefer "returns 200 on GET /api/foo with valid token".

chorus_create_tasks({
  projectUuid: "<project-uuid>",
  tasks: [{
    title: "Fix login redirect loop on Safari",
    description: "Safari loses session cookie after redirect...",
    priority: "high",
    storyPoints: 1,
    acceptanceCriteriaItems: [
      { description: "Login works on Safari 17+", required: true },
      { description: "Existing Chrome/Firefox behavior unchanged", required: true }
    ]
  }]
})

**`proposalUuid` is optional:**

• **Omit** for standalone quick tasks (bug fixes, hotfixes, exploratory work)
• **Pass** to attach the task to an existing proposal — useful for gap-filling, follow-up patches, or continuing work after a proposal's initial tasks are delivered

**Link Quick Tasks to an Idea (`ideaUuid`, optional):** when the work belongs to an existing Idea but does not need a proposal (e.g. a small Idea you can deliver directly), pass a top-level `ideaUuid` instead of `proposalUuid`. Every task in the batch is linked to that Idea, and the Idea's status follows its linked tasks — it completes (`done`) once all of them are `done`/`closed`, with no proposal required.

chorus_create_tasks({
  projectUuid: "<project-uuid>",
  ideaUuid: "<idea-uuid>",
  tasks: [{ title: "...", acceptanceCriteriaItems: [{ description: "...", required: true }] }]
})

• The Idea must be in the same project and must not be a theme; `ideaUuid` and `proposalUuid` are mutually exclusive (the call is rejected if both are set).
• `ideaUuid` belongs at the top level only: a per-task `ideaUuid` inside `tasks[]` is rejected with a validation error (it is never silently dropped).
• Link or relink an existing Quick Task with `chorus_update_task({ taskUuid, ideaUuid: "<idea-uuid>" })`; pass `ideaUuid: null` to clear the link. Proposal tasks cannot carry `ideaUuid` — they reach their Idea through the proposal.
• List an Idea's linked Quick Tasks with `chorus_list_tasks({ projectUuid, ideaUuid })`; `chorus_get_task` returns the task's `ideaUuid`.
• When the **last** linked Quick Task is verified, the Idea's ship-time code-review gateway applies (see `/develop`, Step 8). If it returns `FAIL`, create the fix tasks the same way — Quick Tasks with the same `ideaUuid`. A proposal-less Idea has no idea-completion report (`chorus_create_report` needs a proposal).

Step 2: Claim the Task

chorus_claim_task({ taskUuid: "<task-uuid>" })

Step 3: Edit Details (if needed)

Use `chorus_update_task` to refine the task after creation. Tasks always have AC (creation requires them), but **update them when your understanding changes during development**. Passing `acceptanceCriteriaItems` **replaces** the task's criteria with the provided non-empty set; omit the field to leave them unchanged (it cannot be used to clear AC).

chorus_update_task({
  taskUuid: "<task-uuid>",