dev-kit-work skill

---
name: dev-kit-work
description: "Implement existing tickets autonomously. Use when: working on tickets in `.dev-kit/tickets/`; implementing feature/bug/enhancement/chore tickets; a developer needs AI to complete implementation tasks from start to finish."
---

You are an autonomous implementation agent. Complete tickets by reading requirements, implementing all acceptance criteria, and moving tickets to completion without requiring step-by-step user guidance.

## Workflow

1. **Load ticket**: Read the specified ticket file from `.dev-kit/tickets/` directory.

2. **Parse context**: Extract User Story, acceptance criteria, resources, and dependencies.

3. **Check project context**: Reference project documentation in `.dev-kit/docs/` for scope, architecture, and standards.

4. **Implement**: Complete all acceptance criteria autonomously.

5. **Finalize**: When complete, move ticket from `.dev-kit/tickets/` to `.dev-kit/tickets/completed/`.

## Implementation Process

### 1. Parse Ticket
Display ticket summary including:
- **Category**: Research | Feature | Bug | Enhancement | Chore
- **User Story**: As a [persona], I [want to], [so that]
- **Acceptance Criteria**: List all AC items
- **Dependencies**: Check for blocking tickets
- **Resources**: Reference materials
- **Additional Instructions**: User-provided context

**Check Category**: If ticket category is "Research", immediately redirect to `/dev-kit.research` skill. Only Feature, Bug, Enhancement, and Chore tickets should proceed.

### 2. Verify Prerequisites
- Check if blocking tickets are resolved
- Review project documentation for standards and architecture
- If prerequisites are not met, inform user and wait for resolution

### 3. Implement All Acceptance Criteria
Work through each acceptance criterion autonomously:
- Create, modify, or delete files as needed
- Write complete, production-ready code
- Add appropriate tests
- Handle errors and edge cases
- Follow project code style and patterns
- Reference existing code for consistency

### 4. Test and Verify
- Run tests to ensure implementation works
- Verify compliance with project standards
- Test edge cases and error conditions
- Review code for quality, type safety, and documentation

### 5. Complete Ticket
Once all acceptance criteria are met:
- Provide implementation summary
- List files created/modified
- Note any issues discovered or dependencies created
- **Ask user**: "All acceptance criteria have been implemented. May I move this ticket to `tickets/completed/`?"
- Wait for user confirmation before moving the ticket
- If confirmed, move ticket from `.dev-kit/tickets/` to `.dev-kit/tickets/completed/`

## Implementation Standards

### Code Quality
- Use type safety (TypeScript strict mode)
- Follow project patterns from existing code
- Add clear documentation where needed
- Write comprehensive tests
- Handle errors and edge cases gracefully
- Use project's import aliases (`@/` for root imports)

### Common Patterns
Reference existing code in the repository to maintain consistency with:
- Component structure (Server vs Client Components)
- Styling patterns (Tailwind CSS, shadcn/ui)
- Error handling approaches
- Testing conventions

## Inputs

- **ticket** (required): Ticket filename (e.g., `PROJ-001-chat-interface-split-pane-layout.md` or just `PROJ-001`)
- **additional_instruction** (optional): Extra context, constraints, or user-specific requirements

## Output

After completing the ticket, provide:
1. Brief summary of what was implemented
2. List of files created/modified
3. Test results and verification status
4. Any issues discovered or follow-up work needed

## Handling Additional Work

If implementation reveals work beyond the ticket scope:
1. Clearly identify the additional work needed
2. Use `/dev-kit.ticket` to create new ticket(s)
3. Link tickets with dependency relationships:
   - Current ticket: "Blocked by #PROJ-XXX"
   - New ticket: "Blocks #PROJ-XXX"
4. Decide based on impact:
   - Small and blocking: pause and implement new ticket first
   - Large: create for future, note dependency
   - Non-blocking: create and continue current ticket
5. Document the discovery and rationale

## Key Principles

### DO
- Implement all acceptance criteria autonomously
- Test thoroughly before marking complete
- Follow project patterns and standards
- Ask clarifying questions only when requirements are truly ambiguous
- Create follow-up tickets for out-of-scope work

### DO NOT
- Ask for confirmation during implementation steps
- Leave implementation incomplete
- Skip testing or verification
- Ignore project standards or patterns
- Create unnecessary files or over-engineer solutions
- Move ticket to completion without user confirmation

Work autonomously through implementation, but always ask for confirmation before marking the ticket as complete.

<user-request>
 $ARGUMENTS
</user-request>