Teamwork Exporter Skill
Philosophy
Bridge the gap between technical findings and project execution. Audit reports identify problems; this skill transforms them into tracked, prioritized work items that teams can action.
When to Use This Skill
This skill activates when:
- Audit agents complete their analysis (security, performance, accessibility, quality)
- User says "export to Teamwork", "create tasks from this report"
- Findings need to be tracked in project management
- Technical debt needs to be prioritized and scheduled
Do NOT activate for:
- Single task creation (use teamwork-task-creator instead)
- Quick status checks (use teamwork-integrator instead)
- Manual task updates (escalate to teamwork-specialist)
Core Responsibilities
1. Parse Audit Reports
Recognize and parse these audit report formats:
Markdown reports:
- Headers indicate finding categories
- Severity levels: Critical, High, Medium, Low
- Code blocks show affected code
- File paths and line numbers
JSON reports:
- Structured data from automated tools
- Severity scores (0-10 or Critical/High/Medium/Low)
- File paths and rules violated
- Remediation suggestions
Common audit types:
- Security audits (OWASP Top 10, CVE findings)
- Performance audits (Core Web Vitals, lighthouse scores)
- Accessibility audits (WCAG violations)
- Code quality audits (complexity, standards violations)
2. Convert Findings to Tasks
Transformation rules:
-
Group related findings
- Same file/component
- Same vulnerability type
- Same fix strategy
-
Create epic for multiple related issues
- If 3+ findings in same category
- Example: "Security Fixes - XSS Vulnerabilities"
-
Individual tasks for each finding
- Clear title: "[Type] in [File/Component]"
- Complete description with context
- Remediation steps
- Testing requirements
-
Set appropriate template
- Security/bugs → Bug Report template
- Performance improvements → Little Task template
- Major refactors → Big Task/Epic template
- Completed work needing validation → QA Handoff template
3. Priority Mapping
Map audit severity to Teamwork priority (Critical→P0, High→P1, Medium→P2, Low→P3, Info→P4).
For complete mapping tables, see Priority Mapping.
4. Template Selection Logic
Select appropriate task template based on finding type (security→bug report, performance→little task, etc.).
For complete selection algorithm, see Template Selection.
Audit Type Handlers
Complete transformation examples for each audit type are available in the audit-handlers directory:
- Security Export - Security scan results to Bug Report tasks
- Performance Export - Performance issues to Little Task templates
- Accessibility Export - WCAG violations to Bug Reports or Little Tasks
- Quality Export - Code quality issues to Little Tasks or Epics
Quick Reference
Security: OWASP/CVE findings → Bug Report tasks with CWE classification Performance: Lighthouse/Core Web Vitals → Little Task for optimizations Accessibility: WCAG violations → Bug Reports (Level A/AA) or Little Tasks Code Quality: Complexity/standards → Little Tasks or Epics for refactors
Batch Export Patterns
Three common patterns for organizing multiple findings: Epic with Sub-Tasks (3+ related findings), Priority Buckets (mixed severity), Component-Based (multiple issues in same component).
For complete patterns and structures, see Batch Patterns.
Dependency Management
Auto-detect blocking relationships (database changes block features, security fixes block deployment, etc.) and link tasks appropriately.
For dependency detection patterns, see Dependency Management.
Integration with Audit Agents
The skill receives findings from four audit specialists (security, performance, accessibility, quality) and converts them to appropriate task templates.
For integration details, see Agent Integration.
Teamwork MCP Tools
Uses Teamwork MCP tools loaded via ToolSearch for task creation, project listing, and milestone/epic creation.
For tool reference, see MCP Tools.
Workflow
1. Receive audit report from specialist agent
└─ Parse format (markdown, JSON, structured data)
2. Analyze findings
└─ Group related issues
└─ Determine priority mapping
└─ Select appropriate templates
3. Decide export strategy
└─ Single task vs. epic with sub-tasks
└─ Identify dependencies
4. Load Teamwork MCP tools via ToolSearch
└─ If epic: create parent first
└─ Create individual tasks
└─ Link dependencies
5. Confirm export
└─ List created tasks with links
└─ Provide summary statistics
└─ Suggest next actions
Output Format
After export, provide comprehensive summary:
## Export Summary
**Audit Type:** Security Scan
**Findings:** 12 issues
**Tasks Created:** 13 (1 epic + 12 sub-tasks)
### Created Tasks
#### Epic
- [SEC-2024: Security Fixes - XSS Vulnerabilities](https://example.teamwork.com/tasks/100)
- Priority: P1 (High)
- Sub-tasks: 12
#### Critical (P0)
- [SEC-101: SQL Injection in User Search](https://example.teamwork.com/tasks/101)
#### High (P1)
- [SEC-102: XSS in User Profile](https://example.teamwork.com/tasks/102)
- [SEC-103: XSS in Comment Form](https://example.teamwork.com/tasks/103)
- [SEC-104: CSRF Missing on Forms](https://example.teamwork.com/tasks/104)
#### Medium (P2)
- 8 additional tasks (see epic for full list)
### Dependencies Configured
- SEC-102, SEC-103, SEC-104 depend on SEC-101 (fix core sanitization first)
### Recommended Actions
1. Start with SEC-101 (critical SQL injection)
2. Then tackle P1 XSS issues in parallel
3. Schedule P2 fixes for next sprint
### Next Steps
- Assign tasks to team members
- Set sprint milestones
- Update team on security priorities
Best Practices
DO:
- ✅ Group related findings into epics
- ✅ Map severity to priority accurately
- ✅ Include complete context (files, lines, code)
- ✅ Provide remediation steps
- ✅ Link dependencies
- ✅ Add testing requirements
DON'T:
- ❌ Create 50+ individual tasks (use epics)
- ❌ Lose critical details in conversion
- ❌ Ignore severity levels
- ❌ Create tasks without remediation guidance
- ❌ Forget to link related tasks
Error Handling
Fallback strategies for MCP server unavailability (provide formatted markdown for manual entry) and ambiguous findings (request clarification).
For detailed error handling patterns, see Error Handling.
References
Complete reference materials available in the templates directory:
- Priority Mapping - Severity to priority conversion tables
- Template Selection - Logic for choosing task templates
- Batch Patterns - Epic creation and task grouping strategies
- Dependency Management - Auto-detecting task dependencies
- Agent Integration - How audit agents pass data to exporter
- MCP Tools - Teamwork MCP tools for export
- Error Handling - Fallback strategies when MCP unavailable
Audit Type Handlers
- Security Export - Security findings to bug reports
- Performance Export - Performance issues to tasks
- Accessibility Export - WCAG violations to bug reports
- Quality Export - Code quality issues to refactoring tasks
Use these references to understand transformation patterns and implementation details.