rbin-task-flow 1.19.3 → 1.19.4

package/.cursor/rules/task_estimate.mdc

@@ -1,5 +1,5 @@
 ---
-description: Task time estimation based on task complexity and developer experience level
+description: Task time estimation based on real task complexity for an average developer pace
 globs: **/*
 alwaysApply: true
 ---
@@ -10,41 +10,36 @@ alwaysApply: true
   - **ALL TASKS**: `task-flow: estimate all` → Estimate all tasks
   - When user says "task-flow: estimate X", "estimate X", "estimate X,Y", "estimate all", or "how long will task X take":
     - **READ**: `.task-flow/.internal/tasks.json` to get task details
-    - **CALCULATE**: Time estimate based on task level, complexity signals, and developer experience level
-    - **DISPLAY**: Show time estimate with intervals for 3 experience levels (junior, mid, senior)
-    - **FORMAT**: Show estimates in hours with ranges (e.g., "10-14 hours" for intermediate)
+    - **CALCULATE**: Time estimate based on task level, intrinsic complexity signals, and average development pace
+    - **DISPLAY**: Show a single estimate range for the majority of developers
+    - **FORMAT**: Show estimates in hours with ranges (e.g. "10-14 hours")
 
 - **Estimation Rules:**
-  1. **Base Analysis**: Evaluate the task title and subtasks to infer real task level
-  2. **Experience Levels** (use internally; display "Intermediate" not "Mid-level" to user):
-     - **Junior** (0-2 years): Base time × 1.5 multiplier
-     - **Intermediate** (3-5 years): Base time × 1.0 multiplier (baseline)
-     - **Senior** (6+ years): Base time × 0.7 multiplier
+  1. **Base Analysis**: Evaluate the task title, description, and subtasks to infer the real complexity of the task itself
+  2. **Assumption**: Estimate for an average developer working at an average development pace, without AI acceleration
   3. **Task Level Heuristics**:
      - **Low**: localized change, clear requirement, low ambiguity, low regression risk
      - **Medium**: multi-file implementation, moderate ambiguity, moderate validation needs
      - **High**: architectural, cross-cutting, migration, security, performance, or high-risk change
-  4. **Subtask count is only one signal**: use it to inform scope, but never as the sole estimate driver
-  5. **Intermediate baseline per subtask**:
+  4. **Intrinsic complexity matters first**: scope, ambiguity, dependencies, validation, integration points, and regression risk must outweigh raw subtask count
+  5. **Subtask count is only one signal**: use it to inform scope, but never as the sole estimate driver
+  6. **Baseline per subtask for average pace**:
      - Low-level task: 1.5-2.5 hours
      - Medium-level task: 2.5-4 hours
      - High-level task: 4-6.5 hours
-  6. **Risk and scope adjustment**:
+  7. **Risk and scope adjustment**:
      - Increase estimate when the task mentions integrations, migrations, refactors, security, performance, billing, or architecture work
-  7. **Range Calculation**:
-     - Lower bound: (subtasks × baseline lower) × risk factor × experience multiplier
-     - Upper bound: (subtasks × baseline upper) × risk factor × experience multiplier
+  8. **Range Calculation**:
+     - Lower bound: subtasks × baseline lower × risk factor
+     - Upper bound: subtasks × baseline upper × risk factor
      - Round to nearest hour
 
 - **Estimation Formula:**
   ```
   1. Infer task level: low, medium, or high
-  2. Choose intermediate baseline per subtask from task level
+  2. Choose average-pace baseline per subtask from task level
   3. Apply risk/scope multiplier when complexity indicators exist
-  4. Apply experience multiplier:
-     Junior: × 1.5
-     Intermediate: × 1.0
-     Senior: × 0.7
+  4. Return one range that represents the majority of developers
   ```
 
 - **Display Format:**
@@ -52,10 +47,8 @@ alwaysApply: true
   📊 Time Estimation for Task X: [Task Title]
   
   Based on [N] subtasks and task-level analysis:
-  
-  👶 Junior (0-2 years):      [X-Y] hours
-  👨‍💼 Intermediate (3-5 years): [X-Y] hours
-  👴 Senior (6+ years):       [X-Y] hours
+
+  Average developer, average pace, no AI acceleration: [X-Y] hours
   ```
 
 - **Natural Language Phrases:**
@@ -78,9 +71,7 @@ alwaysApply: true
   
   Based on 5 subtasks and task-level analysis:
   
-  👶 Junior (0-2 years):      15-23 hours
-  👨‍💼 Intermediate (3-5 years): 10-15 hours
-  👴 Senior (6+ years):      7-11 hours
+  Average developer, average pace, no AI acceleration: 10-15 hours
   ```
 
 - **Integration:**
@@ -89,4 +80,4 @@ alwaysApply: true
   - Estimates are informational only (not stored)
 
 - **Principle:**
-  > **Provide realistic time estimates based on real task level, scope, ambiguity, and risk. Subtask count informs scope, but must not be the sole estimation criterion.**
+  > **Provide realistic time estimates for an average developer, based on the real complexity of the task itself. Subtask count informs scope, but must not be the sole estimation criterion, and estimates must not assume AI acceleration.**

package/.task-flow/README.md

@@ -95,10 +95,10 @@ Refactors code from specific task(s). Removes explanatory comments, improves cod
 - `task-flow: refactor all` → Refactors all tasks
 
 ### `task-flow: estimate X` (simplified syntax)
-Estimates time required to complete task(s) based on task level, scope, risk, and developer experience level. Subtask count informs scope, but is not the sole criterion.
+Estimates time required to complete task(s) based on the real complexity of the task, assuming an average developer working at an average pace without AI acceleration. Subtask count informs scope, but is not the sole criterion.
 
 **Output includes:**
-- Time estimates for Junior (0-2 years), Intermediate (3-5 years), and Senior (6+ years) developers
+- A single estimate range for the majority of developers
 - Estimates in hours and business days
 - Recommendation for management with buffer
 

package/bin/cli.js

@@ -42,7 +42,7 @@ program
 
 program
   .command('estimate')
-  .description('Estimate time for task(s) based on subtasks and experience level')
+  .description('Estimate time for task(s) based on real task complexity and average development pace')
   .argument('<taskIds>', 'Task ID(s) to estimate (comma-separated or "all")')
   .option('-p, --path <path>', 'Target directory (default: current directory)')
   .action(async (taskIds, options) => {

package/lib/estimate.js

@@ -55,34 +55,22 @@ async function estimateTask(taskIdsInput, targetPath = process.cwd()) {
       console.log(chalk.blue(`Complexity: ${chalk.yellow(analysis.level)} (${subtaskCount} subtasks)\n`));
 
       console.log(chalk.cyan('─'.repeat(70)));
-      console.log(chalk.magenta.bold('Time Estimates by Experience Level:\n'));
+      console.log(chalk.magenta.bold('Time Estimate for Average Development Pace:\n'));
 
       console.log(chalk.gray(`Signals: ${analysis.signals.join(', ')}\n`));
 
-      const juniorDays = Math.ceil(estimates.junior.upper / 8);
-      const midDays = Math.ceil(estimates.mid.upper / 8);
-      const seniorDays = Math.ceil(estimates.senior.upper / 8);
+      const estimateDays = Math.ceil(estimates.upper / 8);
 
-      console.log(chalk.gray('👶 Junior Developer (0-2 years):'));
-      console.log(chalk.white('   Hours:'), chalk.yellow(`${estimates.junior.lower}-${estimates.junior.upper} hours`));
-      console.log(chalk.white('   Days: '), chalk.yellow(`~${juniorDays} business day(s)`));
-      console.log('');
-
-      console.log(chalk.gray('👨‍💼 Intermediate (3-5 years):'));
-      console.log(chalk.white('   Hours:'), chalk.yellow(`${estimates.mid.lower}-${estimates.mid.upper} hours`));
-      console.log(chalk.white('   Days: '), chalk.yellow(`~${midDays} business day(s)`));
-      console.log('');
-
-      console.log(chalk.gray('👴 Senior Developer (6+ years):'));
-      console.log(chalk.white('   Hours:'), chalk.yellow(`${estimates.senior.lower}-${estimates.senior.upper} hours`));
-      console.log(chalk.white('   Days: '), chalk.yellow(`~${seniorDays} business day(s)`));
+      console.log(chalk.gray('Assumption: average developer, average delivery pace, without AI acceleration.'));
+      console.log(chalk.white('   Hours:'), chalk.yellow(`${estimates.lower}-${estimates.upper} hours`));
+      console.log(chalk.white('   Days: '), chalk.yellow(`~${estimateDays} business day(s)`));
       console.log('');
 
       console.log(chalk.cyan('─'.repeat(70)));
       console.log(chalk.magenta.bold('Recommendation for Management:\n'));
-      console.log(chalk.white('   Recommended estimate:'), chalk.yellow(`${estimates.mid.lower}-${estimates.mid.upper} hours`), chalk.gray('(3-5 years baseline)'));
+      console.log(chalk.white('   Recommended estimate:'), chalk.yellow(`${estimates.lower}-${estimates.upper} hours`), chalk.gray('(average developer baseline)'));
       console.log(chalk.white('   Buffer recommended:'), chalk.yellow(`+20%`), chalk.gray('for unexpected issues'));
-      console.log(chalk.white('   Total estimate:'), chalk.yellow(`${Math.round(estimates.mid.upper * 1.2)} hours`), chalk.gray(`(~${Math.ceil(estimates.mid.upper * 1.2 / 8)} business days)`));
+      console.log(chalk.white('   Total estimate:'), chalk.yellow(`${Math.round(estimates.upper * 1.2)} hours`), chalk.gray(`(~${Math.ceil(estimates.upper * 1.2 / 8)} business days)`));
       console.log('');
 
       successCount++;
@@ -109,18 +97,8 @@ function calculateEstimates(analysis) {
   const baseUpper = subtaskCount * baseRange.upper * riskMultiplier;
 
   return {
-    junior: {
-      lower: Math.round(baseLower * 1.5),
-      upper: Math.round(baseUpper * 1.5)
-    },
-    mid: {
-      lower: baseLower,
-      upper: baseUpper
-    },
-    senior: {
-      lower: Math.round(baseLower * 0.7),
-      upper: Math.round(baseUpper * 0.7)
-    }
+    lower: Math.round(baseLower),
+    upper: Math.round(baseUpper)
   };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rbin-task-flow",
-  "version": "1.19.3",
+  "version": "1.19.4",
   "description": "AI-powered task management for Claude and Cursor",
   "main": "index.js",
   "bin": {