You start defining a project. Three weeks later, you’re still asking questions. You’re not sure if you’re ready to start building. I built Socratic-maturity to track context maturity across 4 phases (Discovery, Analysis, Design, Implementation). It tells you exactly what’s missing. Build when you’re 80% mature. 70% saves you weeks of rework. 50% means you’re building on assumptions.
The Problem: Starting Too Early or Too Late
Scenario 1: Building on Assumptions
Your team decides to build a new feature.
You think you understand what’s needed.
Three weeks of building later, you show it to the customer.
“This isn’t what we wanted.”
Two more weeks rebuilding.
Then again: “Still not right.”
Total: 5 weeks of work for a 2-week project.
Why? You built before the requirements were clear. You were making assumptions.
Scenario 2: Over-Planning Forever
Your team analyzes the feature for 8 weeks.
Every detail is perfectly understood.
You have 500 pages of documentation.
Everyone agrees on every aspect.
The market has moved. Your customer’s needs have changed.
You over-planned. You should have built earlier.
Scenario 3: The Scope Creep
You start building with 80% clarity.
During building, new requirements emerge.
You add features you didn’t plan for.
Timeline extends. Budget explodes.
You built before you had full clarity, but not early enough to avoid rework.
Why It’s Hard to Know When You’re Ready
Different Phases Need Different Clarity
Discovery Phase: Understanding the problem
Do we understand the customer?
Do we understand the market?
Do we understand the problem?
Analysis Phase: Defining the solution
What exactly are we building?
What are the core features?
What can we defer?
Design Phase: Planning how to build it
What architecture?
What technologies?
What are the trade-offs?
Implementation Phase: Actually building
Can we build this?
Do we have the team?
Is the timeline realistic?
Each phase needs different information. You can start implementation when design is mature, even if analysis isn’t perfect.
But how do you know when each phase is mature enough?
Different People Have Different Views
Your product manager thinks you understand the customer. (Maybe not.)
Your architect thinks the design is solid. (Maybe, maybe not.)
Your engineers think the timeline is realistic. (They always think projects will be faster than they are.)
How do you objectively know when you’re ready?
The Solution: Socratic-Maturity
Socratic-maturity tracks context maturity across 4 phases.
It tells you:
What’s mature
What’s still uncertain
What could derail the project
When you’re ready to move to the next phase
Core Metric: Maturity Score
For each phase: How complete is our understanding?
Discovery Phase Maturity: 85%
├─ Customer understanding: 90%
│ ├─ Who are they? ✓ Clear
│ ├─ What's their pain? ✓ Clear
│ ├─ What's their budget? ⚠️ Approximate
│ └─ What's their timeline? ✓ Clear
│
├─ Market understanding: 80%
│ ├─ How big is market? ✓ Estimate
│ ├─ Who are competitors? ✓ Identified
│ ├─ What's our differentiation? ⚠️ Unclear
│ └─ What's TAM? ⚠️ Rough estimate
│
└─ Problem understanding: 85%
├─ What's the core problem? ✓ Clear
├─ What's the context? ✓ Clear
├─ What are constraints? ⚠️ Some unknowns
└─ What's success? ✓ Defined
Recommendation:
├─ Status: ✓ Ready for Analysis Phase
├─ What's good: Core problem is clear
├─ What's missing: Market TAM needs clarification
└─ Next step: Begin detailed analysis
Example: Analysis Phase Maturity
Analysis Phase Maturity: 68% ⚠️ Not quite ready
├─ Core features defined: 75%
│ ├─ Feature A: ✓ Clear
│ ├─ Feature B: ✓ Clear
│ ├─ Feature C: ⚠️ Vague
│ └─ Feature D: ❌ Undefined
│
├─ Secondary features identified: 60%
│ ├─ Nice-to-have items: ⚠️ Long list, not prioritized
│ └─ Future roadmap: ❌ Not discussed
│
├─ Scope boundaries: 65%
│ ├─ What's in scope? ⚠️ Mostly clear
│ ├─ What's out of scope? ⚠️ Some ambiguity
│ └─ Phase 1 scope? ⚠️ Not decided
│
└─ Priorities: 60%
├─ What matters most? ⚠️ Team disagrees
├─ What's optional? ❌ Not discussed
└─ What can we defer? ❌ Unclear
Recommendation:
├─ Status: ⚠️ Not ready for Design Phase (need 80%)
├─ What's good: Core features mostly clear
├─ What's missing:
│ ├─ Feature C and D need definition
│ ├─ Priorities need resolution
│ ├─ Secondary features need categorization
│ └─ Scope boundaries need clarification
├─ Effort to reach 80%: 2-3 more days of work
└─ Risk if you start design now:
├─ Will need rework when features clarified
├─ Scope creep likely (unclear boundaries)
└─ Timeline overrun probable
Maturity as a Decision Framework
Maturity Score → Decision
90%+ : Build with confidence. Rework risk is low.
80-89%: Build. Some rework likely but manageable.
70-79%: Building is risky. Expect significant rework.
60-69%: Building is unwise. Finish analysis first.
<60%: Too immature. Continue discovery/analysis.
Tracking Over Time
Analysis Phase Maturity Over Time
90% ┤ ╱╲
80% ┤ ╱ ╲╱╲ Ready
70% ┤ ╱ Warning ╲
60% ┤ ╱ ╲╱╲
50% ┤ ╱ Risky ╲
└──────────────────────────
Day 1 Day 5 Day 10
Day 1: 50% (just started analysis)
Day 3: 65% (some clarification, still risky)
Day 5: 75% (getting clearer, still warning zone)
Day 7: 88% (ready!)
Day 8: 85% (new issue discovered, slipped slightly)
Day 10: 92% (resolved, now confident)
Timeline to readiness: 10 days
If built on day 5: Rework likely
If built on day 7: Manageable
If built on day 10: Smooth execution expected
Real Impact: Examples
Case Study 1: Catching Premature Building
A team wanted to build a feature.
Day 1 – Maturity Assessment:
Discovery: 65% (customer needs unclear)
Analysis: 40% (requirements vague)
Design: 10% (no tech decisions)
Overall: 40% (too early!)
Team wanted to start building immediately.
Maturity assessment said: “Wait. You’ll waste weeks if you build now.”
They spent 3 more days in discovery and analysis.
Result:
Discovered the customer’s actual need was different
Changed the approach completely
Building took 3 weeks instead of 5 weeks (avoided 2 weeks rework)
Delivered exactly what customer wanted
Case Study 2: Knowing When to Stop Planning
A team was analyzing a feature for 8 weeks.
Week 6 – Maturity Assessment:
Discovery: 95% (customer perfectly understood)
Analysis: 92% (requirements crystal clear)
Design: 88% (good design decisions made)
Overall: 92% (more than ready!)
Team wanted to keep planning.
Maturity assessment said: “Stop. You’re ready now. Continuing to plan wastes time.”
They started building week 7.
Result:
Built and delivered in 4 weeks
If they’d kept planning: 2 more weeks of planning, then building
Saved 2 weeks by knowing when to stop
Case Study 3: Detecting Scope Creep Risk
A team was starting design with 75% analysis maturity.
Maturity assessment:
Features defined: 70%
Scope boundaries: 60%
Risk: “Scope creep likely due to undefined boundaries”
Team built anyway.
4 weeks into design:
New feature discovered that should be included
Scope expanded
Timeline extended 2 weeks
If they’d waited 2 more days for 90% maturity:
Would have discovered the feature earlier
Would have included it in original scope
No delay
Implementation: Tracking Maturity
Step 1: Start Assessment
from socratic_maturity import MaturityTracker
tracker = MaturityTracker(project_id="my_project")
Create project
project = await tracker.create_project(
name="New Feature",
description="..."
)
Step 2: Track Phase Completion
Mark discovery complete
await tracker.complete_phase(
project_id="my_project",
phase="discovery",
confidence=0.85 # 85% confident we understand customer
)
System calculates what's missing
maturity = await tracker.get_maturity(project_id="my_project")
print(f"Discovery maturity: {maturity.discovery:.0%}")
print(f"What's missing: {maturity.discovery_gaps}")
Step 3: Get Recommendations
Should we move to next phase?
recommendation = await tracker.get_phase_recommendation(
project_id="my_project"
)
print(f"Current phase: {recommendation.current_phase}")
print(f"Maturity: {recommendation.maturity:.0%}")
print(f"Ready for next phase? {recommendation.ready_for_next}")
print(f"What's missing: {recommendation.gaps}")
print(f"Days to readiness: {recommendation.days_to_ready}")
Step 4: Track Over Time
View maturity trajectory
history = await tracker.get_maturity_history(project_id="my_project")
for date, maturity in history:
print(f"{date}: {maturity:.0%} (phase: {maturity.phase})")
Step 5: Make Go/No-Go Decision
Final decision: build or continue planning?
maturity = await tracker.get_maturity(project_id="my_project")
if maturity.overall >= 0.80:
print("✓ Ready to build")
elif maturity.overall >= 0.70:
print("⚠️ Can build but expect rework")
elif maturity.overall >= 0.60:
print("❌ Too risky to build. Finish analysis.")
else:
print("❌ Way too early. Continue discovery.")
The Philosophy: Readiness Matters
Building too early wastes time through rework.
Building too late wastes time through over-planning.
The sweet spot is 80% maturity: You understand enough to build. You’re flexible enough to adapt. You’re not over-committing to details that might change.
Socratic-maturity helps you find that sweet spot for every project.
Use Socratic-Maturity for Project Readiness
The project maturity tracking system described in this post is production-ready and open source:
GitHub: https://github.com/Nireus79/Socrates
PyPI Package: https://pypi.org/project/socratic-maturity/
Documentation: https://github.com/Nireus79/Socrates/tree/main/socratic-maturity
Quick Start
Install the maturity tracker
pip install socratic-maturity
from socratic_maturity import MaturityTracker
tracker = MaturityTracker()
Create project and track phases
project = await tracker.create_project(name="New Feature")
Complete discovery phase
await tracker.complete_phase(
project_id=project.id,
phase="discovery",
confidence=0.90
)
Check maturity
maturity = await tracker.get_maturity(project_id=project.id)
print(f"Discovery: {maturity.discovery:.0%}")
print(f"Ready for analysis? {maturity.discovery >= 0.80}")
Get recommendation
rec = await tracker.get_phase_recommendation(project_id=project.id)
print(f"Recommendation: {rec.recommendation}")
Full examples and documentation: https://github.com/Nireus79/Socrates
The Complete Socratic Ecosystem
Socratic-maturity is part of the complete Socrates AI system (11 modules, 2,300+ tests):
Socratic-nexus: Multi-provider LLM client
Socratic-morality: Constitutional governance with 13 modules
Socratic-agents: Multi-agent orchestration with conflict resolution
Socratic-knowledge: Enterprise RAG with multi-tenancy
Socratic-learning: Self-improving agents
Socratic-analyzer: Code quality analysis
Socratic-performance: Real-time monitoring
Socratic-workflow: Workflow orchestration
Socratic-conflict: Conflict resolution between agents
Socratic-docs: Auto-documentation
Socratic-maturity: Project maturity tracking(this post)
All modules work together seamlessly. Use individual packages or the complete platform.
Available on PyPI under MIT License: https://pypi.org/user/Nireus79/