Quick Estimate Operator

The Quick Estimate Operator command generates effort estimates for development tasks by analyzing code complexity, historical velocity data, and task decomposition patterns. It examines the scope of proposed changes, compares against similar past tasks, and produces calibrated story point or time-based estimates. Run this command when you need data-informed estimates for sprint planning, roadmap projections, or stakeholder communication.

When to Use This Command

Run this command when...

• You need story point estimates for upcoming tasks during sprint planning and want to reduce estimation bias
• You want to decompose a large feature into smaller tasks with individual estimates that sum to a realistic total
• You are preparing a project timeline and need effort estimates calibrated against your team's historical velocity
• You need to compare the estimated effort of different implementation approaches to inform architectural decisions
• You want to identify tasks that are likely more complex than they appear by analyzing the codebase areas they affect

Consider alternatives when...

• Estimates are needed for non-technical tasks like documentation or design work that this tool cannot analyze from code
• Your team uses a no-estimates approach and does not assign story points or time estimates to tasks
• You need precise time tracking rather than forward-looking estimates

Quick Start

Copy
# estimate-config.yml
methodology:
  unit: "story-points"
  scale: [1, 2, 3, 5, 8, 13]
  confidence-interval: true
data-sources:
  velocity: "linear"
  code-complexity: true
  historical-tasks: true
decomposition:
  auto-breakdown: true
  max-task-size: 8

Example invocation:

Copy
/quick-estimate-operator --task "Add user profile editing with avatar upload" --decompose

Example output:

Estimation Report
==================
Task: "Add user profile editing with avatar upload"
Team velocity: 34 points/sprint (avg last 3 sprints)

Decomposition:
  1. Profile form component (UI + validation)    3 pts
  2. Avatar upload with crop and resize           5 pts
  3. API endpoint for profile updates             2 pts
  4. API endpoint for avatar storage              3 pts
  5. Database schema update                       1 pt
  6. Integration tests                            3 pts

Total estimate: 17 story points
Confidence: Medium (70-80%)
Risk factors:
  - Avatar processing may require third-party service integration
  - File upload size limits need infrastructure verification

Sprint fit: Approximately 50% of one sprint at current velocity
Recommendation: Split across 2 sprints with avatar upload in sprint 2

Core Concepts

Concept	Purpose	Details
Code Complexity Analysis	Inform effort assessment	Examines cyclomatic complexity, file count, and dependency breadth of affected code areas to gauge implementation difficulty
Historical Calibration	Reduce estimation bias	Compares proposed tasks against completed tasks with similar characteristics to produce calibrated estimates based on actual team performance
Task Decomposition	Break down large work items	Splits large tasks into smaller, estimable units that fall within the team's typical task size range
Confidence Intervals	Communicate uncertainty	Provides optimistic, likely, and pessimistic estimates to help stakeholders understand the range of possible outcomes
Velocity Integration	Context-aware sizing	Uses the team's historical velocity data to translate story point estimates into calendar time and sprint capacity planning

Architecture: Estimation Pipeline
====================================

+-------------------+     +---------------------+     +------------------+
| Task Analyzer     | --> | Complexity Scanner  | --> | History Matcher  |
| (scope assessment)|     | (code analysis)     |     | (similar tasks)  |
+-------------------+     +---------------------+     +------------------+
                                                             |
                          +----------------------------------+
                          v
              +---------------------+     +-------------------+
              | Decomposition Engine| --> | Estimate Assembler|
              | (break into units)  |     | (points + range)  |
              +---------------------+     +-------------------+

Configuration

Parameter	Type	Default	Description
task	string	required	Description of the task or feature to estimate
decompose	boolean	true	Automatically break the task into smaller estimable sub-tasks
unit	string	"story-points"	Estimation unit: story-points using Fibonacci scale, or hours for time-based estimates
confidence	boolean	true	Include confidence intervals with optimistic and pessimistic bounds alongside the likely estimate
compare	boolean	true	Compare against similar historical tasks to calibrate the estimate

Best Practices

1. Decompose tasks before estimating the total. Estimating a single large feature produces less accurate results than estimating each sub-task independently and summing the results. Decomposition forces consideration of all the work involved and reveals hidden complexity that broad estimates overlook.

2. Calibrate against historical velocity regularly. As your team's capabilities and codebase evolve, historical estimates become less representative. Re-calibrate by reviewing the accuracy of recent estimates against actual completion times and adjust the estimation model to reflect current team performance.

3. Include risk factors explicitly in your estimates. Every estimate should note the assumptions it depends on and the risks that could cause the actual effort to exceed the estimate. Making risks visible during planning enables proactive mitigation rather than reactive schedule adjustments.

4. Use confidence intervals when communicating to stakeholders. A single number creates false precision. Presenting a range such as "13 to 21 story points with 17 most likely" gives stakeholders a realistic understanding of the uncertainty involved and sets appropriate expectations for delivery timing.

5. Review estimate accuracy after sprint completion. Compare estimated story points against actual effort for completed tasks. Systematic overestimation or underestimation signals calibration issues that can be corrected by adjusting the complexity weights or historical comparison parameters.

Common Issues

Estimates consistently undercount integration effort. Task-level estimates often capture the implementation work but miss the integration, testing, and deployment effort required to ship the feature end to end. Include explicit sub-tasks for integration testing, code review cycles, and deployment verification in the decomposition.

Historical comparison matches against non-representative tasks. The history matcher may find tasks with similar titles but fundamentally different scope or complexity. Review matched historical tasks to ensure they are genuinely comparable before relying on their completion data for calibration.

Decomposition produces too many small tasks. Automatic decomposition can split a task into granular units that individually take less than an hour, creating administrative overhead that exceeds the implementation effort. Set a minimum task size threshold to prevent over-decomposition and keep the task list manageable.