Agent skill
ticket-create
Guides creation of well-structured tickets (task documents). This skill should be used when the user wants to create a ticket, task, feature request, bug report, or any work item that needs to be tracked and potentially assigned. Provides structure hints without enforcing rigid templates - the final structure adapts to the specific task and domain.
Install this agent skill to your Project
npx add-skill https://github.com/malhashemi/dotfiles/tree/main/dot_config/opencode/skill/caster/ticket-create
SKILL.md
Ticket Create
Overview
This skill augments Caster's document creation workflow for tickets - task documents that describe work to be done. Tickets can represent features, bugs, improvements, research tasks, or any actionable work item.
When to Use
- User wants to create a ticket, task, or work item
- User has scattered thoughts about work that needs to be done
- User says things like "I need to track this", "let's create a ticket for...", "this should be a task"
- The
/ticket-createcommand is invoked
Document Type
Type: Ticket (task document)
Unlike context packs (reference material), tickets are actionable - they describe work to be completed. They typically move through states (draft → active → completed) and may be assigned to someone.
Ticket Complexity
Tickets vary significantly in scope. Match structure to complexity:
| Complexity | Example | Typical Length | Structure |
|---|---|---|---|
| Simple | Bug fix, small task | 50-150 lines | Summary + Requirements + Acceptance Criteria |
| Medium | Feature addition | 150-400 lines | Summary + Context + Requirements + Implementation Notes + AC |
| Large | System refactor | 400-1500+ lines | Summary + Numbered Parts + Decisions + Questions + AC |
For large tickets, use numbered Parts to organize complex content:
## Part 1: Overview## Part 2: Component A## Part 3: Component B- etc.
Workflow Adaptations
When creating a ticket, adapt Caster's standard workflow:
Gap Analysis Focus
During gap analysis, specifically look for:
- What needs to be done (the actual task)
- Why it matters (context, motivation, impact)
- Scope boundaries (what's included, what's explicitly excluded)
- Success criteria (how to know when it's done)
- Dependencies (what must happen first, what this blocks)
Clarification Questions
Prioritize questions about:
- Scope and boundaries - what's in, what's out?
- Success criteria - how will completion be measured?
- Priority and urgency - how important is this relative to other work?
- Dependencies - does this block or depend on other work?
- Assignment - who should work on this?
Structure Proposal
Propose structure based on the specific task, not a fixed template. Common sections include:
| Section | When to Include |
|---|---|
| Summary | Always - numbered list of key changes/requirements |
| Context/Background | When motivation or history matters |
| Parts (numbered) | For large tickets with multiple components |
| Requirements/Scope | When task has specific deliverables |
| Decisions Made | When documenting choices (table format) |
| Resolved Questions | When key decisions need rationale |
| Acceptance Criteria | When success needs to be measurable (checkboxes) |
| Implementation Notes | For technical tasks with design decisions |
| Open Questions | When decisions are still pending |
| References | Links to relevant code, docs, or other tickets |
Do NOT enforce all sections - include only what serves this specific ticket.
Frontmatter
Generating Git Context
Before creating frontmatter, run the metadata script to get git context:
.opencode/scripts/spec_metadata.sh
Or use thoughts metadata to get current values.
Complete Frontmatter Structure
---
# Git context (from metadata script)
date: 2025-01-15T10:30:00+03:00
researcher: username # Who created this
git_commit: abc1234
branch: feature/my-feature
repository: project-name
# Document type
kind: ticket
status: draft # draft | active | blocked | implemented | verified | abandoned
topic: "Brief Descriptive Title"
tags: [feature, api, refactor] # Categorization
source: manual # manual | linear | github | jira
# Priority and tracking
priority: 2 # 0-4 (P0=critical, P4=backlog)
schema_version: 1
# References (enables wiki-links)
aliases:
- ticket-2025-01-15-descriptive-slug
# Optional fields
assignee: alice # Who's responsible
due: 2025-02-01 # YYYY-MM-DD deadline
depends_on: # What must complete first
- "[[other-ticket-alias]]"
# Change tracking (updated automatically on edits)
last_updated: 2025-01-15T10:30:00+03:00
last_updated_by: username
last_updated_note: "Initial creation"
---
Minimal Frontmatter (for simple tickets)
---
date: 2025-01-15T10:30:00+03:00
researcher: username
kind: ticket
status: draft
topic: "Fix login button alignment"
tags: [bug, ui]
priority: 3
aliases:
- ticket-2025-01-15-login-button-fix
---
Save Location
Tickets are saved to the current project's thoughts directory:
{project}/thoughts/shared/tickets/YYYY-MM-DD_descriptive-slug.md
After saving, remind the user to run thoughts sync to commit and push changes.
Alias Convention
Format: {kind}-{YYYY-MM-DD}-{descriptive-slug}
Examples:
ticket-2025-01-15-user-auth-flowticket-2025-01-15-api-rate-limitingticket-2025-01-15-dashboard-redesign
Acceptance Criteria Format
Use checkbox format for testable criteria:
## Acceptance Criteria
### Category 1
- [ ] Specific measurable criterion
- [ ] Another criterion with expected behavior
### Category 2
- [ ] Third criterion
Group related criteria under subheadings for large tickets.
Quality Checklist
Before finalizing, verify:
- Summary clearly states what needs to be done
- Scope is defined (or explicitly open-ended)
- Success criteria exist (even if informal)
- Alias follows convention
- Frontmatter has appropriate fields for this ticket
- Structure matches ticket complexity
Remember
Tickets are living documents. Start lean - it's better to have a clear, focused ticket than a comprehensive but bloated one. The ticket can be updated as understanding evolves. For large refactors, expect multiple review rounds to refine the specification.
Recommended Agent Skills
Expand your agent's capabilities with these related and highly-rated skills.
phase-execution
Your bulletproof guide to executing implementation phases! Handles commits, detects when phases are too big, and knows when to bail cleanly. Load this whenever you're implementing a phase - it provides clean commit protocol and signals the orchestrator when things go sideways.
parallel-research
Research scope too big? This skill decomposes large questions into independent parts, spawns parallel researchers, and synthesizes findings. Essential when comprehensive research would overflow a single context window.
plan-review
Catch oversized phases BEFORE implementation begins! This skill reviews plans for sizing, dependencies, and completeness - flagging phases that need decomposition before a single line of code is written. Load this when validating plans pre-implementation.
brand-palette
Brand color discovery and palette generation skill. This skill should be used when helping users create brand color palettes, design systems, or Tailwind color configs. It guides through hue selection (RYB color wheel), chroma/tone decisions, and generates Obsidian-compatible palette reports with APCA accessibility validation. Supports starting from hex color or OKLCH values for refinement workflows. Triggers: "brand colors", "palette", "color scheme", "design system colors", "Tailwind colors", "generate palette from hex", "generate palette from OKLCH", or when users describe brand values that imply color decisions.
pr-review-orchestration
Automated PR review cycle for RPIV orchestration. Waits for Gemini reviews, assesses feedback, implements fixes, and manages the review loop. Used by Planner agent after RPIV opens PRs. This skill is triggered automatically by RPIV when entering the PR Review phase.
pr-review
This skill provides a complete workflow for handling GitHub Pull Request reviews, specifically optimized for @gemini-code-assist automated reviews. This skill should be used when addressing PR review comments, responding to reviewers, resolving threads, requesting re-reviews, or merging PRs after feedback is addressed. Triggers include: /pr-review command, "address PR feedback", "handle review comments", "respond to gemini", or any PR review lifecycle management request.
Didn't find tool you were looking for?