agent-task-workflow

name	agent-task-workflow
description	Universal task approach patterns for coding agents: operating modes, task workflow, lightweight mode, scope safety, verification matrix, definition of done, and quality checklist.

Agent Task Workflow

Standardized approach patterns for every coding agent. Use this skill to determine how to approach tasks of any size.

Operating Modes

Choose execution depth based on user intent and task complexity.

Mode	When	Workflow
fast	Tiny, low-risk tasks (typo, spacing, icon swap, single-field edit)	Minimal planning, minimal diff, skip MCP lookups if local pattern is clear
balanced	Default — normal feature work	Moderate planning, load skills when needed, run proportional checks
thorough	Complex/risky tasks (auth, data flow, many files, cross-cutting changes)	Deep analysis, wider verification, explicit trade-off discussion

If user does not specify mode, infer automatically from task size and risk.

Task Approach Pattern

For each task, follow this protocol:

1. Understand
   - Read requirements carefully
   - Identify constraints and goals
   - Read only files needed for scope; infer local patterns first

2. Plan
   - Load relevant skills
   - Identify affected files
   - Define minimal set of touched files
   - Consider edge cases and failure modes

3. Implement
   - Write clean, typed code following project conventions
   - Keep changes small and explicit
   - Reuse existing helpers and middleware patterns

4. Verify
   - Run checks proportional to risk (see Verification Matrix)
   - If checks cannot run, report exact commands to run
   - Review for best practices and edge cases

5. Report
   - What changed (1-3 bullets)
   - Files touched (explicit paths)
   - Verification status

Lightweight Mode for Simple Tasks

For small, low-risk requests, use a minimal-change workflow.

Trigger Lightweight Mode when ALL are true:

• Change touches 1-2 files
• No API contract, auth, database, or routing changes
• No architecture or state-management redesign
• Request is clear and implementation is straightforward

Lightweight Mode protocol:

1. Read the target file(s) and existing local pattern
2. Implement the smallest correct change
3. Do a quick verification (type/lint/build check only if immediately relevant)
4. Return concise result with changed file path(s)

Skip by default:

• Full multi-step planning narrative
• Broad skill-loading announcements
• Extended documentation updates
• Extra refactors unrelated to the request

Guardrail: If hidden complexity appears (cross-file impact, uncertain behavior, failing checks), immediately switch back to the full Task Approach Pattern.

Scope Safety Rules (Non-Negotiable)

• Modify only files required by the user request
• Do not perform opportunistic refactors outside scope
• Do not change project-wide config (build, lint, tsconfig, CI, env) unless requested
• Prefer smallest diff that fully solves the task
• Preserve repository conventions over personal preference
• If unrelated local changes exist, leave them untouched

Output Contract (Response Format)

For every implementation task, end with this concise structure:

1. What changed (1-3 bullets)
2. Files touched (explicit paths)
3. Verification status (verified | partially_verified | not_verified)
4. If not fully verified: exact commands user should run
5. Optional next step (only if natural)

Verification Matrix

Task Size	Required Checks
Tiny	Optional targeted check; no full build required by default
Small	At least one relevant check (lint OR typecheck OR focused test)
Medium+	Lint + typecheck + relevant tests when permitted

If commands are restricted by permissions:

1. Continue non-blocked work first
2. Attempt lower-privilege verification (static review, targeted checks allowed)
3. Report what could not be executed with explicit commands for manual execution
4. Mark verification as partially_verified or not_verified

Definition of Done

Tiny Task (single-file, trivial UI/content tweak)

• Requested change implemented with minimal diff
• Existing local pattern preserved
• No unrelated file edits
• Verification status reported (verified / partially_verified / not_verified)

Small Task (1-3 files, localized behavior change)

• All Tiny Task criteria met
• Edge states for touched UI considered (loading/error/empty where relevant)
• Type safety and lint impact reviewed for touched code
• If runtime checks blocked, provide exact commands for user to run

Medium+ Task (cross-file feature/refactor)

• All Small Task criteria met
• Clear implementation notes and trade-offs provided
• Validation performed with available checks (tests/lint/build as appropriate)
• Follow-up risks or TODOs explicitly listed

Quality Checklist

Before marking any task as complete, verify:

• Code follows project conventions
• TypeScript strict mode compliance (or language-equivalent)
• Loading, error, and empty states handled
• No console.log statements left
• No hardcoded secrets or sensitive values
• Imports are organized
• Code is accessible (labels, focus, contrast)
• Responsive design implemented (for UI tasks)
• Performance implications considered
• Tests would be easy to write for this code