Current session: !`source "${CLAUDE_PLUGIN_ROOT}/scripts/state.sh" && get_current_session 2>/dev/null || echo "No active session"`
Executes development tasks through automated planning, agent selection, quality gates, and iterative improvement cycles.
npx claudepluginhub michael-harris/devteamThis skill inherits all available tools. When active, it can use any tool Claude has access to.
Current session: !source "${CLAUDE_PLUGIN_ROOT}/scripts/state.sh" && get_current_session 2>/dev/null || echo "No active session"
Active sprint: !source "${CLAUDE_PLUGIN_ROOT}/scripts/state.sh" && get_kv_state "active_sprint" 2>/dev/null || echo "None"
Failure count: !source "${CLAUDE_PLUGIN_ROOT}/scripts/state.sh" && get_kv_state "consecutive_failures" 2>/dev/null || echo "0"
Command: /devteam:implement [task] [options]
Execute implementation work - plans, sprints, tasks, or ad-hoc work.
# Execute selected/current plan
/devteam:implement
# Execute specific sprint
/devteam:implement --sprint 1
/devteam:implement --sprint SPRINT-001
# Execute all sprints
/devteam:implement --all
# Execute specific task
/devteam:implement --task TASK-001
# Ad-hoc task (will trigger interview if ambiguous)
/devteam:implement "Add pagination to user list"
# Cost-optimized execution
/devteam:implement --eco
/devteam:implement --sprint 1 --eco
# Skip interview for ad-hoc tasks
/devteam:implement "Fix typo in header" --skip-interview
# Specify task type for better agent selection
/devteam:implement "Audit auth flow" --type security
/devteam:implement "Restructure utils" --type refactor
| Option | Description |
|---|---|
--sprint <id> | Execute specific sprint |
--all | Execute all sprints sequentially |
--task <id> | Execute specific task |
--eco | Cost-optimized execution (slower escalation, summarized context) |
--skip-interview | Skip ambiguity check for ad-hoc tasks |
--type <type> | Specify task type: feature, bug, security, refactor, docs |
--model <model> | Force starting model: haiku, sonnet, opus |
--max-iterations <n> | Override max iterations (default: 10) |
--show-worktrees | Debug: Show worktree operations (normally hidden) |
# Source state management
source "${CLAUDE_PLUGIN_ROOT}/scripts/state.sh"
source "${CLAUDE_PLUGIN_ROOT}/scripts/events.sh"
# Start session
SESSION_ID=$(start_session "/devteam:implement $*" "implement")
log_session_started "/devteam:implement $*" "implement"
# Determine execution mode
if [[ "$*" == *"--eco"* ]]; then
set_state "execution_mode" "eco"
fi
Create/update session in database:
INSERT INTO sessions (
id, command, command_type, execution_mode, status, current_phase
) VALUES (
'session-xxx', '/devteam:implement --sprint 1', 'implement', 'normal', 'running', 'initializing'
);
Priority order:
--task TASK-001 -> Execute single task--sprint 1 -> Execute specific sprint--all -> Execute all sprints"ad-hoc task" -> Create and execute ad-hoc taskfunction determineTarget(args) {
if (args.task) return { type: 'task', id: args.task }
if (args.sprint) return { type: 'sprint', id: args.sprint }
if (args.all) return { type: 'all_sprints' }
if (args._.length > 0) return { type: 'adhoc', description: args._.join(' ') }
return { type: 'plan', id: getSelectedPlan() }
}
Skip if:
--skip-interview flag presentTrigger interview if:
// Check for ambiguity
const ambiguityIndicators = [
description.split(' ').length < 5, // Too short
/fix|broken|doesn't work|issue/i.test(description) && !description.includes('when'),
/add|create|implement/i.test(description) && !description.includes('to'),
!description.includes(' ') // Single word
]
if (ambiguityIndicators.some(x => x) && !args.noInterview) {
await runInterview('adhoc_task', description)
}
Interview questions for ad-hoc tasks:
adhoc_task:
triggers:
- pattern: "fix|broken|bug"
redirect: bug_interview
- pattern: "add|create|implement"
questions:
- key: scope
question: "What component/area should this be added to?"
- key: requirements
question: "What are the specific requirements?"
- key: acceptance
question: "How will we know when this is complete?"
Based on task type and content, select appropriate agents.
# Agent selection weights
selection_weights:
keywords: 40%
file_types: 30%
task_type: 20%
language: 10%
# Task type overrides
task_type_agents:
security:
primary: quality:security-auditor
support: [security:penetration-tester, security:compliance-engineer]
refactor:
primary: quality:refactoring-coordinator
support: [frontend:code-reviewer]
bug:
primary: diagnosis:root-cause-analyst
support: [orchestration:bug-council-orchestrator]
Normal Mode:
complexity_based:
1-4: haiku
5-8: sonnet
9-14: opus
Eco Mode:
eco_mode:
default: haiku
exceptions:
- security: sonnet
- architecture: sonnet
- complexity_10_plus: sonnet
TASK LOOP
Execute <-------- Fix Tasks
Agent(s) |
| |
v |
Quality -- FAIL --> Create Fix
Gates Tasks
| |
PASS ESCALATE?
| |
v v
Complete Upgrade
+ Report Model
Max Iterations: 10 (normal) / 10 (eco, slower escalation)
Escalation thresholds:
| Mode | haiku->sonnet | sonnet->opus | opus->council |
|---|---|---|---|
| Normal | 2 failures | 2 failures | 3 failures |
| Eco | 4 failures | 4 failures | 4 failures |
Run all applicable quality gates:
const gates = [
{ name: 'tests', command: 'npm test', required: true },
{ name: 'typecheck', command: 'npm run typecheck', required: true },
{ name: 'lint', command: 'npm run lint', required: true },
{ name: 'security', command: 'npm audit', required: false },
{ name: 'coverage', command: 'npm run coverage', threshold: 80 }
]
for (const gate of gates) {
const result = await runGate(gate)
log_gate_passed(gate.name) // or log_gate_failed()
if (!result.passed && gate.required) {
createFixTask(gate, result.errors)
}
}
On success:
log_session_ended('completed', 'All quality gates passed')
end_session('completed', 'Success')
// Output completion message
console.log(`
IMPLEMENTATION COMPLETE
Task: ${taskDescription}
Files Changed:
${filesChanged.map(f => ` - ${f}`).join('\n')}
Quality Gates:
Tests: ${testCount} passing
Types: No errors
Lint: Clean
Coverage: ${coverage}%
Iterations: ${iterations}
Model Usage: ${modelBreakdown}
Cost: $${totalCost}
EXIT_SIGNAL: true
`)
On max iterations:
log_session_ended('failed', 'Max iterations reached')
end_session('failed', 'Max iterations reached')
console.log(`
MAX ITERATIONS REACHED
The task could not be completed within ${maxIterations} iterations.
Remaining Issues:
${remainingIssues.map(i => ` - ${i}`).join('\n')}
Recommendation: Review the issues above and either:
1. Run /devteam:implement again with more context
2. Break the task into smaller pieces
3. Manually address the blocking issues
EXIT_SIGNAL: true
`)
Worktrees are fully automatic. Users never need to interact with worktrees directly - the system creates, uses, merges, and cleans them up transparently.
Worktrees are automatically created when:
parallel_tracks.mode: "worktrees" in state// Auto-detect and create worktrees at execution start
async function initializeExecution(plan) {
const parallelTracks = plan.parallel_tracks?.track_info
if (parallelTracks && Object.keys(parallelTracks).length > 1) {
// Multiple tracks - use worktrees for isolation
for (const [trackId, trackInfo] of Object.entries(parallelTracks)) {
const worktreePath = `.multi-agent/track-${trackId}`
const branchName = `dev-track-${trackId}`
if (!existsSync(worktreePath)) {
// Create worktree silently
await exec(`git worktree add ${worktreePath} -b ${branchName}`)
log_event('worktree_created', { track: trackId, path: worktreePath })
}
}
}
}
Each track's sprints execute in their isolated worktree:
async function executeTrackSprint(trackId, sprintId) {
const worktreePath = `.multi-agent/track-${trackId}`
// Change to worktree directory for all operations
process.chdir(worktreePath)
try {
await executeSprint(sprintId)
// Auto-commit progress
await exec('git add -A')
await exec(`git commit -m "Complete ${sprintId} in track ${trackId}"`)
// Auto-push for backup (silent failure ok)
await exec(`git push -u origin dev-track-${trackId}`)
} finally {
// Return to main repo
process.chdir(mainRepoPath)
}
}
When all tracks are complete, auto-merge occurs:
async function checkAndAutoMerge() {
const state = loadState()
const tracks = state.parallel_tracks?.track_info
if (!tracks) return // Single track, no merge needed
// Check if all tracks complete
const allComplete = Object.values(tracks).every(t => t.status === 'completed')
if (allComplete) {
console.log('All tracks complete - auto-merging...')
// Merge each track sequentially
for (const trackId of Object.keys(tracks).sort()) {
const branchName = `dev-track-${trackId}`
// Merge with descriptive commit
await exec(`git merge ${branchName} -m "Merge track ${trackId}: ${tracks[trackId].name}"`)
log_event('track_merged', { track: trackId })
}
// Auto-cleanup worktrees
await cleanupWorktrees()
log_event('all_tracks_merged', { count: Object.keys(tracks).length })
}
}
After successful merge, worktrees are removed automatically:
async function cleanupWorktrees() {
const worktreeDir = '.multi-agent'
// Get all worktrees
const worktrees = await exec('git worktree list --porcelain')
for (const worktree of parseWorktrees(worktrees)) {
if (worktree.path.includes('.multi-agent')) {
// Remove worktree (keeps branch for history)
await exec(`git worktree remove ${worktree.path}`)
log_event('worktree_removed', { path: worktree.path })
}
}
// Remove .multi-agent directory if empty
if (existsSync(worktreeDir) && readdirSync(worktreeDir).length === 0) {
rmdirSync(worktreeDir)
}
}
For advanced users who want to see worktree operations:
/devteam:implement --sprint 1 --show-worktrees
.multi-agent/ (gitignored)--delete-branches in debug commands to remove)/devteam:worktree status for diagnosticsWhen executing a sprint (--sprint or --all):
async function executeSprint(sprintId) {
const sprint = await loadSprint(sprintId)
set_active_sprint(sprintId)
for (const task of sprint.tasks) {
log_task_started(task.id, task.description)
try {
await executeTask(task)
log_task_completed(task.id)
} catch (error) {
log_task_failed(task.id, error.message)
// Continue to next task or abort based on task priority
if (task.blocking) throw error
}
}
// Sprint complete
updateSprintStatus(sprintId, 'completed')
}
Starting:
DevTeam Implementation
Target: Sprint SPRINT-001 (3 tasks)
Mode: Normal
Model: sonnet (complexity: 6)
Starting execution...
Progress:
Task 1/3: Implement user authentication
Agent: backend:api-developer-typescript
Model: sonnet
Iteration: 1
Progress:
Created auth middleware
Added JWT validation
Writing tests...
Quality Gates:
Pending...
Escalation:
Model Escalation
Reason: 2 consecutive test failures
Action: sonnet -> opus
Retrying with enhanced reasoning...
Track costs in real-time:
// After each agent call
const cost = calculateCost(model, tokensInput, tokensOutput)
add_tokens(tokensInput, tokensOutput, cost)
log_agent_completed(agent, model, filesChanged, tokensInput, tokensOutput, cost)
// Cost calculation (cents)
function calculateCost(model, input, output) {
const rates = {
haiku: { input: 0.025, output: 0.125 }, // per 1K tokens
sonnet: { input: 0.3, output: 1.5 },
opus: { input: 1.5, output: 7.5 }
}
const rate = rates[model]
return Math.ceil((input * rate.input + output * rate.output) / 10)
}
try {
await executeImplementation()
} catch (error) {
if (error.type === 'circuit_breaker') {
log_error('Circuit breaker tripped', { failures: consecutiveFailures })
// Wait and retry or abort
} else if (error.type === 'rate_limit') {
log_warning('Rate limit approaching', { usage: currentUsage })
// Throttle execution
} else {
log_error(error.message, { stack: error.stack })
end_session('failed', error.message)
}
}
/devteam:plan - Create plans before implementing/devteam:bug - Fix bugs with diagnostic workflow/devteam:status - Check implementation progress/devteam:list - List available plans and sprintsActivates when the user asks about AI prompts, needs prompt templates, wants to search for prompts, or mentions prompts.chat. Use for discovering, retrieving, and improving prompts.
Search, retrieve, and install Agent Skills from the prompts.chat registry using MCP tools. Use when the user asks to find skills, browse skill catalogs, install a skill for Claude, or extend Claude's capabilities with reusable AI agent components.
Creating algorithmic art using p5.js with seeded randomness and interactive parameter exploration. Use this when users request creating art using code, generative art, algorithmic art, flow fields, or particle systems. Create original algorithmic art rather than copying existing artists' work to avoid copyright violations.