home / skills / aj-geddes / useful-ai-prompts / gap-analysis
This skill identifies gaps between current capabilities and a desired future state to guide strategic investments and targeted improvements.
npx playbooks add skill aj-geddes/useful-ai-prompts --skill gap-analysisReview the files below or copy the command above to add this skill to your agents.
---
name: gap-analysis
description: Identify differences between current state and desired future state. Analyze gaps in capabilities, processes, skills, and technology to plan improvements and investments.
---
# Gap Analysis
## Overview
Gap analysis systematically compares current capabilities with desired future state, revealing what needs to change and what investments are required.
## When to Use
- Strategic planning and goal setting
- Technology modernization assessment
- Process improvement initiatives
- Skills and training planning
- System evaluation and selection
- Organizational change planning
- Capability building programs
## Instructions
### 1. **Gap Identification Framework**
```python
# Systematic gap identification
class GapAnalysis:
GAP_CATEGORIES = {
'Business Capability': 'Functions organization can perform',
'Process': 'How work gets done',
'Technology': 'Tools and systems available',
'Skills': 'Knowledge and expertise',
'Data': 'Information available',
'People/Culture': 'Team composition and mindset',
'Organization': 'Structure and roles',
'Metrics': 'Ability to measure performance'
}
def identify_gaps(self, current_state, future_state):
"""Compare current vs desired and find gaps"""
gaps = []
for capability in future_state['capabilities']:
current_capability = self.find_capability(
capability['name'],
current_state['capabilities']
)
if current_capability is None:
gaps.append({
'capability': capability['name'],
'gap_type': 'Missing',
'description': f"Organization lacks {capability['name']}",
'importance': capability['importance'],
'impact': 'High' if capability['importance'] == 'Critical' else 'Medium'
})
elif current_capability['maturity'] < capability['target_maturity']:
gaps.append({
'capability': capability['name'],
'gap_type': 'Maturity',
'current_maturity': current_capability['maturity'],
'target_maturity': capability['target_maturity'],
'gap_size': capability['target_maturity'] - current_capability['maturity'],
'importance': capability['importance'],
'impact': 'Medium'
})
return gaps
def prioritize_gaps(self, gaps):
"""Rank gaps by importance and effort"""
scored_gaps = []
for gap in gaps:
importance = self.score_importance(gap)
effort = self.estimate_effort(gap)
value = importance / effort if effort > 0 else 0
scored_gaps.append({
**gap,
'importance_score': importance,
'effort_score': effort,
'value_score': value,
'priority': self.assign_priority(value)
})
return sorted(scored_gaps, key=lambda x: x['value_score'], reverse=True)
def score_importance(self, gap):
"""Score how important gap is"""
if gap['importance'] == 'Critical':
return 10
elif gap['importance'] == 'High':
return 7
else:
return 4
def estimate_effort(self, gap):
"""Estimate effort to close gap"""
# Returns 1-10 scale
return gap.get('effort_estimate', 5)
def assign_priority(self, value_score):
"""Assign priority based on value"""
if value_score > 2:
return 'High'
elif value_score > 1:
return 'Medium'
else:
return 'Low'
```
### 2. **Gap Analysis Template**
```yaml
Gap Analysis Report:
Organization: Customer Analytics Platform
Analysis Date: January 2025
Prepared For: Executive Team
---
Executive Summary:
Current State: Legacy on-premise system with manual processes
Future State: Cloud-native platform with real-time analytics
Gap Magnitude: Significant
Key Findings:
- 7 critical capability gaps
- Estimated investment: $500K - $750K
- Timeline: 12-18 months
- Primary gaps: Technology, Process, Skills
---
Detailed Gap Analysis:
## Category: Technology
Gap 1: Cloud Infrastructure
Current: On-premise data center
Desired: Multi-cloud (AWS primary, Azure backup)
Gap Size: Large
Effort: 16 weeks
Cost: $200K
Dependencies: None (can start immediately)
Priority: Critical
Gap 2: Real-Time Data Processing
Current: Batch processing (nightly)
Desired: Streaming (sub-second latency)
Gap Size: Large
Effort: 20 weeks
Cost: $150K
Dependencies: Cloud infrastructure (Gap 1)
Priority: High
Gap 3: Analytics Tools
Current: Custom-built dashboard
Desired: Enterprise BI platform (Tableau/Power BI)
Gap Size: Medium
Effort: 8 weeks
Cost: $80K (software + training)
Dependencies: Data warehouse modernization
Priority: High
---
## Category: Skills
Gap 4: Cloud Engineering Expertise
Current: 0 cloud engineers
Desired: 3 dedicated cloud engineers
Gap Size: Large
Solution: Hire 2, train 1 existing
Effort: 8 weeks hiring + 4 weeks training
Cost: $300K annual
Priority: Critical
Gap 5: Data Science Capability
Current: 1 analyst (spreadsheet based)
Desired: 3 data scientists (ML/Python)
Gap Size: Large
Solution: Hire 2 data scientists
Effort: 12 weeks recruiting
Cost: $400K annual
Priority: High
---
## Category: Process
Gap 6: Continuous Integration/Deployment
Current: Manual deployment (quarterly)
Desired: Automated CI/CD (daily)
Gap Size: Medium
Effort: 12 weeks
Cost: $60K (tools + training)
Dependencies: Cloud infrastructure
Priority: High
Gap 7: Data Governance
Current: Informal, ad-hoc
Desired: Formal governance framework
Gap Size: Small
Effort: 4 weeks
Cost: $20K (training + tools)
Dependencies: None
Priority: Medium
---
## Gap Closure Plan
High Priority Gaps (Start Now):
1. Cloud Infrastructure - 16 weeks
2. Cloud Engineering Skills - 8 weeks + training
3. Data Governance Framework - 4 weeks
Medium Priority Gaps (Start after Cloud ready):
1. Real-Time Data Processing - 20 weeks (depends on Gap 1)
2. Analytics Tools - 8 weeks
3. CI/CD Implementation - 12 weeks
---
Investment Summary:
Capital Expenditure:
- Cloud infrastructure setup: $200K
- Technology/tools: $250K
- Hiring/recruitment: $50K
- Total CapEx: $500K
Operational Expenditure (Annual):
- Cloud services: $150K
- Tool licenses: $80K
- Salary (3 engineers): $700K
- Total OpEx: $930K
---
Timeline: 12-18 Months
Q1 2025: Planning & Infrastructure
- Finalize architecture
- Begin cloud migration
- Recruit cloud engineers
Q2 2025: Development & Hiring
- Cloud infrastructure operational
- Data engineering foundation
- Hire data scientists
Q3 2025: Analytics Platform
- Deploy real-time pipeline
- Implement BI tools
- User training
Q4 2025: Production Launch
- Full platform operational
- Legacy system decommission
- Performance optimization
---
Success Metrics:
Before:
- Query time: 24 hours (batch)
- Data freshness: 1 day old
- Cost: $100K/month
- User satisfaction: 2.5/5
After:
- Query time: <1 second (real-time)
- Data freshness: Real-time
- Cost: $60K/month (40% reduction)
- User satisfaction: 4.5/5
ROI: Break-even in 18 months
```
### 3. **Gap Closure Planning**
```javascript
// Create action plans to close gaps
class GapClosurePlanning {
createClosurePlan(gap) {
return {
gap_id: gap.id,
gap_description: gap.description,
target_state: gap.target_state,
approach: gap.gap_type === 'Maturity'
? this.createMaturityPlan(gap)
: this.createCapabilityPlan(gap),
timeline: {
start_date: gap.start_date,
target_completion: gap.target_date,
duration_weeks: Math.ceil(gap.effort_estimate),
milestones: this.defineMilestones(gap)
},
resources: {
people: gap.required_staff,
budget: gap.estimated_cost,
tools: gap.required_tools
},
success_criteria: gap.success_metrics,
risks: this.identifyClosureRisks(gap),
dependencies: gap.dependencies
};
}
createMaturityPlan(gap) {
// Plan for improving existing capability
return {
strategy: 'Improve capability maturity',
phases: [
{
phase: 'Assess Current',
activities: ['Document current state', 'Identify improvement areas'],
duration: '2 weeks'
},
{
phase: 'Plan Improvements',
activities: ['Define target maturity', 'Create roadmap', 'Allocate resources'],
duration: '2 weeks'
},
{
phase: 'Implement',
activities: ['Execute improvement', 'Training', 'Process changes'],
duration: gap.effort_estimate + ' weeks'
},
{
phase: 'Validate',
activities: ['Measure against targets', 'Validate maturity', 'Document learnings'],
duration: '2 weeks'
}
]
};
}
createCapabilityPlan(gap) {
// Plan for building new capability
return {
strategy: 'Build new capability',
phases: [
{
phase: 'Design',
activities: ['Define requirements', 'Design solution', 'Get approvals'],
duration: '4 weeks'
},
{
phase: 'Build',
activities: ['Develop', 'Test', 'Integrate'],
duration: gap.effort_estimate + ' weeks'
},
{
phase: 'Deploy',
activities: ['Pilot', 'Roll out', 'Support transition'],
duration: '4 weeks'
}
]
};
}
defineMilestones(gap) {
return [
{ name: 'Gap closure initiated', date_offset: 'Week 0' },
{ name: 'First deliverable', date_offset: `Week ${Math.ceil(gap.effort_estimate / 3)}` },
{ name: 'Mid-point review', date_offset: `Week ${Math.ceil(gap.effort_estimate / 2)}` },
{ name: 'Final validation', date_offset: `Week ${gap.effort_estimate}` }
];
}
}
```
### 4. **Communication & Tracking**
```yaml
Gap Analysis Communication:
Stakeholder Updates:
Executive Summary (1 page):
- What gaps exist?
- Why do they matter?
- What's the investment?
- When will we close them?
Detailed Report (10 pages):
- Gap identification methodology
- Gap descriptions and impacts
- Priority and sequencing
- Detailed closure plans
- Risk assessment
Team Briefing (30 min):
- Overview of gaps
- Impact on team
- Their role in closure
- Timeline and changes
---
Tracking Dashboard:
Gap 1: Cloud Infrastructure
Status: In Progress (40%)
Timeline: On track
Budget: On budget ($200K allocated, $80K spent)
Next Milestone: Infrastructure provisioning (due Feb 15)
Gap 2: Cloud Engineering Skills
Status: Not started
Timeline: At risk (delayed by hiring)
Budget: On budget
Next Milestone: 2nd engineer hire (due Feb 28)
Gap 3: Data Governance
Status: Completed
Timeline: Complete
Budget: Under budget ($18K vs $20K)
Business Impact: 30% improvement in data quality
```
## Best Practices
### ✅ DO
- Compare current to clearly defined future state
- Include all relevant capability areas
- Involve stakeholders in gap identification
- Prioritize by value and effort
- Create detailed closure plans
- Track progress to closure
- Document gap analysis findings
- Review and update analysis quarterly
- Link gaps to business strategy
- Communicate findings transparently
### ❌ DON'T
- Skip current state assessment
- Create vague future state
- Identify gaps without solutions
- Ignore implementation effort
- Plan all gaps in parallel
- Forget about dependencies
- Ignore resource constraints
- Hide difficult findings
- Plan for 100% effort allocation
- Forget about change management
## Gap Analysis Tips
- Involve people doing the work
- Be realistic about effort estimates
- Start with highest-value gaps
- Build dependencies and sequencing
- Monitor progress weekly
This skill identifies differences between a current state and a desired future state to reveal capability, process, skills, data, people, and technology gaps. It produces prioritized gap lists and practical closure plans to guide investments, hiring, and timelines. The output helps leaders sequence work, estimate effort and cost, and track progress toward the target state.
The skill compares documented current capabilities against a defined future state across categories like technology, processes, skills, data, metrics, and culture. It identifies missing capabilities and maturity shortfalls, scores importance and effort, and ranks gaps by value to assign priority. It then generates closure plans with phases, milestones, resources, risks, and success criteria and formats stakeholder communications and tracking dashboards.
What inputs are required to run a gap analysis?
A current-state inventory (capabilities, processes, tools, skills, metrics) and a clear, measurable future-state definition with target maturity and importance for each capability.
How are priorities assigned?
Gaps are scored by importance and estimated effort; value is importance divided by effort. Value ranges map to High/Medium/Low priority and drive sequencing based on dependencies and risk.