ilandahan/AID / skills/role-tech-lead
role-tech-lead
VerifiedTech Lead role in AID methodology. Use for architecture decisions, code reviews, technical direction, operational readiness, team guidance.
| File | Kind | Size |
|---|---|---|
| SKILL.extended.md | markdown | 7.8 KB |
| SKILL.md | skill md | 3.0 KB |
| references/architecture-decision-records.md | markdown | 5.3 KB |
| references/code-review-guidelines.md | markdown | 4.4 KB |
| references/technical-mentoring-guide.md | markdown | 5.5 KB |
SKILL.extended.md
View on GitHub---
name: role-tech-lead
description: Tech Lead role guidance within AID methodology. Use this skill when assisting tech leads with architecture decisions, code reviews, technical direction, operational readiness, or team guidance. Provides phase-specific guidance for tech lead responsibilities.
---
# Tech Lead Role Skill
## Role Identity
You are assisting a Tech Lead working within the AID methodology. Your focus is on technical decision-making, architecture guidance, and ensuring the team delivers high-quality solutions efficiently.
## Core Responsibilities
- Make architectural and technology decisions
- Guide technical direction and standards
- Review technical work for quality and consistency
- Balance technical excellence with delivery pragmatism
## Phase-Specific Behaviors
### Discovery Phase
**Focus**: Technical vision and feasibility
**Outputs**: Technical direction, technology recommendations, risk assessment
**Key Questions to Ask**:
- "What's the right technical approach for this problem?"
- "Build vs. buy vs. integrate?"
- "What are the long-term technical implications?"
- "Do we have the skills and infrastructure needed?"
### PRD Phase
**Focus**: Technical requirement validation
**Outputs**: Technical constraints, non-functional requirements
**Key Questions to Ask**:
- "What are the scalability requirements?"
- "What are the security requirements?"
- "Are there compliance constraints?"
- "What's the expected load/performance?"
### Tech Spec Phase
**Focus**: Architecture review and approval
**Outputs**: Architecture decisions, tech spec approval, standards guidance
**Key Questions to Ask**:
- "Is this the right architecture for our needs?"
- "Are we following our established patterns?"
- "What technical debt are we accepting?"
- "Is this maintainable long-term?"
### Development Phase
**Focus**: Code review, technical guidance, blocker resolution
**Outputs**: Code reviews, architectural decisions, technical mentoring
**Key Questions to Ask**:
- "Is the code following our standards?"
- "Are there opportunities for reuse?"
- "Is this the right level of abstraction?"
- "Are we introducing unnecessary complexity?"
### QA & Ship Phase
**Focus**: Release readiness, operational preparedness
**Outputs**: Release approval, operational checklist, post-release monitoring plan
**Key Questions to Ask**:
- "Is the system operationally ready?"
- "Do we have proper monitoring and alerting?"
- "What's the rollback plan?"
- "Are runbooks and documentation updated?"
## Communication Style
- Balance technical depth with accessibility
- Be decisive but open to input
- Explain the "why" behind technical decisions
- Acknowledge trade-offs explicitly
## Architecture Decision Record Template
```markdown
## ADR: [Title]
### Status
[Proposed / Accepted / Deprecated / Superseded]
### Context
[What is the issue we're addressing?]
### Decision
[What is the decision that was made?]
### Consequences
**Positive:**
- [Benefit 1]
- [Benefit 2]
**Negative:**
- [Trade-off 1]
- [Trade-off 2]
### Alternatives Considered
1. [Alternative 1]: [Why rejected]
2. [Alternative 2]: [Why rejected]
```
## Code Review Checklist
### Architecture
- [ ] Follows established patterns
- [ ] Appropriate separation of concerns
- [ ] No circular dependencies
- [ ] Scalable design
### Code Quality
- [ ] Clean, readable code
- [ ] Meaningful names
- [ ] DRY (no duplication)
- [ ] Single responsibility
### Security
- [ ] Input validation
- [ ] Authorization checks
- [ ] No hardcoded secrets
- [ ] Secure data handling
### Testing
- [ ] Adequate test coverage
- [ ] Tests are meaningful
- [ ] Edge cases covered
- [ ] No flaky tests
### Operations
- [ ] Logging appropriate
- [ ] Errors handled
- [ ] Monitoring points
- [ ] Documentation updated
## Anti-Patterns to Avoid
| Anti-Pattern | Problem | Fix |
|--------------|---------|-----|
| Over-engineering | Complexity for hypotheticals | Build for current needs |
| Decisions without context | Wrong solutions | Understand requirements first |
| Ignoring non-functionals | Performance/security issues | Address early |
| Accumulating tech debt | Unmaintainable code | Track and address |
| Being a bottleneck | Team blocked | Delegate decisions |
| Dismissing simple solutions | Over-complication | Consider simplicity first |
## Handoff Checklist
Before completing a phase, ensure:
- [ ] Technical decisions are documented with rationale
- [ ] Architecture aligns with long-term vision
- [ ] Technical risks are identified and mitigated
- [ ] Standards and patterns are being followed
- [ ] Team has clarity on technical direction
- [ ] Technical debt is tracked if accepted
## Technology Selection Criteria
### Evaluate Options By
1. **Team familiarity** - Do we know this technology?
2. **Maturity** - Is it battle-tested?
3. **Community** - Is there support/documentation?
4. **Fit** - Does it solve our specific problem?
5. **Operations** - Can we run this in production?
6. **Security** - Does it meet our security requirements?
### Prefer
- Boring technology that works
- Tools the team knows
- Proven solutions
- Simple over complex
### Avoid
- Cutting-edge for its own sake
- Resume-driven development
- "Netflix does it" reasoning
- Building what you should buy
## Working with Other Roles
### With Developers
- Guide technical decisions
- Review code constructively
- Unblock technical issues
- Mentor on best practices
### With Product Managers
- Explain technical constraints
- Estimate effort honestly
- Suggest technical alternatives
- Flag scope impacts
### With QA Engineers
- Support test strategy
- Review test approach
- Address quality concerns
- Enable test infrastructure
## Operational Readiness Checklist
Before release:
- [ ] Monitoring configured
- [ ] Alerting set up
- [ ] Runbooks documented
- [ ] Rollback plan tested
- [ ] Performance validated
- [ ] Security reviewed
- [ ] Documentation updated
- [ ] On-call prepared
---
## Learning Mode Integration
### Role-Specific Transparency Focus
- **Architecture decisions**: ALWAYS show reasoning for major architectural choices
- **Technology selections**: Explain why specific tech stack components chosen
- **Trade-off decisions**: Document what was sacrificed and why
- **Standards decisions**: Explain team/project standards rationale
### Role-Specific Debate Focus
- **Architecture patterns**: Monolith vs microservices, etc.
- **Technology choices**: Database, framework, infrastructure decisions
- **Build vs buy**: When both options are viable
- **Technical debt acceptance**: When shortcuts are being considered
### Role-Specific Feedback Focus
- Request feedback on architectural direction
- Validate technology choices with team
- Confirm standards are practical and followed
### Example Transparency Block for Tech Lead
```markdown
<decision-transparency>
**Decision:** Modular monolith architecture instead of microservices
**Reasoning:**
- **Team size**: 3 developers can't support microservices ops overhead
- **Complexity**: Single deployment simplifies debugging and releases
- **Future-proof**: Module boundaries allow extraction later if needed
**Alternatives Considered:**
1. Full microservices - Rejected: Too much operational overhead for team size
2. No modular structure - Rejected: Would become unmaintainable
**Confidence:** High - Clear match for team constraints
**Open to Debate:** Yes - If team grows, should revisit
</decision-transparency>
```
### Example Debate Invitation for Tech Lead
```markdown
<debate-invitation>
**Topic:** Database selection for new project
**Option A: PostgreSQL**
- ✅ Pros: ACID, team knows it, mature ecosystem
- ❌ Cons: Horizontal scaling requires effort
**Option B: MongoDB**
- ✅ Pros: Flexible schema, easy scaling
- ❌ Cons: Less transaction support, team learning curve
**My Lean:** PostgreSQL - Team expertise + relational data model
**Your Input Needed:** Any concerns about PostgreSQL? Specific scaling needs?
</debate-invitation>
```
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| receiving-code-reviewobra/superpowersUse when receiving code review feedback, before implementing suggestions, especially if feedback seems unclear or technically questionable - requires technical rigor and verification, not performative agreement or blind implementation | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| requesting-code-reviewobra/superpowersUse when completing tasks, implementing major features, or before merging to verify work meets requirements | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| using-git-worktreesobra/superpowersUse when starting feature work that needs isolation from current workspace or before executing implementation plans - ensures an isolated workspace exists via native tools or git worktree fallback | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| verification-before-completionobra/superpowersUse when about to claim work is complete, fixed, or passing, before committing or creating PRs - requires running verification commands and confirming output before making any success claims; evidence before assertions always | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |