# Workflow Optimizer

> Elimina cuellos de botella en procesos de desarrollo. Usa este skill para optimizar CI/CD, reducir cycle time, mejorar developer experience, y hacer que el equipo sea más productivo.

- Skill: `leandroomargarcia/workflow-optimizer` (Agent Skill)
- Install (CLI): `npx skillmds@latest add leandroomargarcia/workflow-optimizer`
- Raw SKILL.md: https://api.skillmd.com/api/skills/leandroomargarcia/workflow-optimizer/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: DevOps & Infra
- Author: leandroomargarcia (https://skillmd.com/u/leandroomargarcia)
- Updated: 2026-09-22
- Page: https://skillmd.com/skills/leandroomargarcia/workflow-optimizer

---


# Workflow Optimizer

Especialista en identificar y eliminar fricción en procesos de desarrollo. Hace que los equipos sean más productivos optimizando el how del trabajo.

## Cuándo Usar Este Skill

- Optimizar pipelines de CI/CD
- Reducir cycle time
- Mejorar developer experience
- Automatizar tareas repetitivas
- Eliminar bottlenecks de proceso
- Streamline deployments

## Developer Velocity Metrics

```
CYCLE TIME:
- Code complete → In production
- Target: <24 hours

DEPLOYMENT FREQUENCY:
- How often we deploy
- Target: Multiple per day

LEAD TIME:
- Idea → Production
- Track and reduce

CHANGE FAILURE RATE:
- % deployments causing issues
- Target: <5%

MTTR:
- Time to recover from failure
- Target: <1 hour
```

## CI/CD Optimization

```
SPEED IMPROVEMENTS:

CACHING:
☐ Dependency caching
☐ Build caching
☐ Docker layer caching
☐ Test result caching

PARALLELIZATION:
☐ Split test suites
☐ Parallel builds
☐ Matrix builds
☐ Concurrent jobs

EFFICIENCY:
☐ Incremental builds
☐ Affected-only testing
☐ Skip unnecessary steps
☐ Optimize Docker builds

INFRASTRUCTURE:
☐ Faster runners
☐ Self-hosted if needed
☐ Regional optimization
☐ Resource right-sizing
```

## Pipeline Audit

```markdown
## CI/CD Pipeline Audit

### Current State
- Total time: X minutes
- Jobs: Y
- Success rate: Z%

### Time Breakdown
| Stage | Time | % Total | Optimizable |
|-------|------|---------|-------------|
| Checkout | 30s | 5% | ✓ Cache |
| Install | 3m | 30% | ✓ Cache |
| Build | 4m | 40% | ✓ Parallel |
| Test | 2m | 20% | ✓ Shard |
| Deploy | 30s | 5% | - |

### Bottlenecks
1. [Bottleneck]: [Impact] → [Solution]
2. [Bottleneck]: [Impact] → [Solution]

### Optimization Plan
| Action | Expected Savings | Effort |
|--------|------------------|--------|
| Add caching | -2 min | Low |
| Parallelize tests | -3 min | Medium |

### Target State
- Total time: X-5 minutes
- Success rate: >99%
```

## Developer Experience Audit

```
DAILY FRICTION POINTS:

ENVIRONMENT:
☐ How long to set up from scratch?
☐ Works on all dev machines?
☐ Docker/containerized?
☐ Env vars documented?

DEVELOPMENT:
☐ Hot reload working?
☐ Tests run fast locally?
☐ Linting/formatting automatic?
☐ Debug setup documented?

CODE REVIEW:
☐ PR template helpful?
☐ Review turnaround fast?
☐ CI feedback quick?
☐ Merge process smooth?

DEPLOYMENT:
☐ Can deploy independently?
☐ Rollback easy?
☐ Feature flags available?
☐ Staging environment works?
```

## Automation Opportunities

```
AUTOMATE WHEN:
- Task is repetitive (>3 times)
- Task is error-prone
- Task blocks other work
- Task is time-sensitive
- Human judgment not required

COMMON AUTOMATIONS:
- PR labeling
- Changelog generation
- Version bumping
- Dependency updates
- Security scanning
- Performance checks
- Documentation generation
- Notification routing
```

## Process Optimization

```
IDENTIFY WASTE (Lean):

WAITING:
- Waiting for reviews
- Waiting for approvals
- Waiting for environments
→ Reduce by: async processes, clear SLAs

HANDOFFS:
- Between teams
- Between systems
- Between stages
→ Reduce by: ownership, automation

CONTEXT SWITCHING:
- Multiple projects
- Interruptions
- Meetings
→ Reduce by: focus time, batching

REWORK:
- Bugs found late
- Unclear requirements
- Miscommunication
→ Reduce by: shift left, collaboration
```

## Meeting Optimization

```
MEETINGS TO ELIMINATE:
- Status updates (use async)
- Approval meetings (use tools)
- FYI meetings (use docs/video)

MEETINGS TO KEEP:
- Problem solving
- Brainstorming
- Team building
- 1:1s

MEETING HYGIENE:
☐ Agenda required
☐ Right people only
☐ Time-boxed
☐ Action items captured
☐ Could this be async?
```

## Workflow Improvements

```markdown
## Workflow Improvement: [Name]

### Current State
[Description of current process]

Pain points:
1. [Pain point 1]
2. [Pain point 2]

Metrics:
- Time: X
- Error rate: Y%
- Satisfaction: Z/5

### Proposed Change
[Description of improved process]

Expected improvements:
1. [Improvement 1]
2. [Improvement 2]

### Implementation
1. [Step 1]
2. [Step 2]

### Success Metrics
- Time: X-Y
- Error rate: <Z%
- Satisfaction: >W/5

### Rollout Plan
- Pilot: [team/project]
- Feedback: [how to collect]
- Full rollout: [timeline]
```

## Tools for Optimization

```
CI/CD:
- GitHub Actions
- GitLab CI
- CircleCI
- BuildKite

AUTOMATION:
- GitHub Apps
- Zapier/n8n
- Custom bots

MONITORING:
- LinearB
- Sleuth
- Swarmia

DOCUMENTATION:
- Notion
- Confluence
- Docusaurus
```

## Change Management

```
INTRODUCING CHANGES:

1. COMMUNICATE
   - Why the change
   - What's changing
   - How it helps

2. PILOT
   - Small group first
   - Gather feedback
   - Iterate

3. TRAIN
   - Documentation
   - Walkthrough
   - Q&A session

4. ROLLOUT
   - Gradual expansion
   - Support available
   - Feedback loop

5. MEASURE
   - Track adoption
   - Measure impact
   - Adjust as needed
```

## Mejores Prácticas

1. **Measure before optimizing** - Know your baseline
2. **Small changes** - Iterative improvements compound
3. **Listen to the team** - They know the pain points
4. **Automate the boring** - Save human time for human problems
5. **Document everything** - Tribal knowledge doesn't scale
6. **Celebrate wins** - Motivate continued improvement

## Filosofía

> "The fastest code is the code you never have to write. The best process is the one you never have to think about."

El objetivo es hacer que el trabajo fluya sin fricción, permitiendo al equipo enfocarse en crear valor en lugar de pelear con procesos.