use 1.5h as model average PR latency

Author: tstromberg

cmd/prcost/main.go

@@ -35,7 +35,7 @@ func main() {
 	days := flag.Int("days", 60, "Number of days to look back for PR modifications")
 
 	// Modeling flags
-	modelMergeTime := flag.Duration("model-merge-time", 1*time.Hour, "Model savings if average merge time was reduced to this duration")
+	targetMergeTime := flag.Duration("target-merge-time", 90*time.Minute, "Target merge time for efficiency modeling (default: 90 minutes / 1.5 hours)")
 
 	flag.Usage = func() {
 		fmt.Fprintf(os.Stderr, "Usage: %s [options] <PR_URL>\n", os.Args[0])
@@ -100,11 +100,13 @@ func main() {
 	cfg.AnnualSalary = *salary
 	cfg.BenefitsMultiplier = *benefits
 	cfg.EventDuration = time.Duration(*eventMinutes) * time.Minute
+	cfg.TargetMergeTimeHours = targetMergeTime.Hours()
 
 	slog.Debug("Configuration",
 		"salary", cfg.AnnualSalary,
 		"benefits_multiplier", cfg.BenefitsMultiplier,
 		"event_minutes", *eventMinutes,
+		"target_merge_time_hours", cfg.TargetMergeTimeHours,
 		"delivery_delay_factor", cfg.DeliveryDelayFactor)
 
 	// Retrieve GitHub token from gh CLI
@@ -122,7 +124,7 @@ func main() {
 		if *repo != "" {
 			// Single repository mode
 
-			err := analyzeRepository(ctx, *org, *repo, *samples, *days, cfg, token, *dataSource, modelMergeTime)
+			err := analyzeRepository(ctx, *org, *repo, *samples, *days, cfg, token, *dataSource)
 			if err != nil {
 				log.Fatalf("Repository analysis failed: %v", err)
 			}
@@ -133,7 +135,7 @@ func main() {
 				"samples", *samples,
 				"days", *days)
 
-			err := analyzeOrganization(ctx, *org, *samples, *days, cfg, token, *dataSource, modelMergeTime)
+			err := analyzeOrganization(ctx, *org, *samples, *days, cfg, token, *dataSource)
 			if err != nil {
 				log.Fatalf("Organization analysis failed: %v", err)
 			}
@@ -177,7 +179,7 @@ func main() {
 		// Output in requested format
 		switch *format {
 		case "human":
-			printHumanReadable(&breakdown, prURL, *modelMergeTime, cfg)
+			printHumanReadable(&breakdown, prURL, cfg)
 		case "json":
 			encoder := json.NewEncoder(os.Stdout)
 			encoder.SetIndent("", "  ")
@@ -209,7 +211,7 @@ func authToken(ctx context.Context) (string, error) {
 }
 
 // printHumanReadable outputs a detailed itemized bill in human-readable format.
-func printHumanReadable(breakdown *cost.Breakdown, prURL string, modelMergeTime time.Duration, cfg cost.Config) {
+func printHumanReadable(breakdown *cost.Breakdown, prURL string, cfg cost.Config) {
 	// Helper to format currency with commas
 	formatCurrency := func(amount float64) string {
 		return fmt.Sprintf("$%s", formatWithCommas(amount))
@@ -313,9 +315,9 @@ func printHumanReadable(breakdown *cost.Breakdown, prURL string, modelMergeTime
 	// Print efficiency score
 	printEfficiency(breakdown)
 
-	// Print modeling callout if PR duration exceeds model merge time
-	if breakdown.PRDuration > modelMergeTime.Hours() {
-		printMergeTimeModelingCallout(breakdown, modelMergeTime, cfg)
+	// Print modeling callout if PR duration exceeds target merge time
+	if breakdown.PRDuration > cfg.TargetMergeTimeHours {
+		printMergeTimeModelingCallout(breakdown, cfg)
 	}
 }
 
@@ -528,8 +530,8 @@ func mergeVelocityGrade(avgOpenDays float64) (grade, message string) {
 }
 
 // printMergeTimeModelingCallout prints a callout showing potential savings from reduced merge time.
-func printMergeTimeModelingCallout(breakdown *cost.Breakdown, targetMergeTime time.Duration, cfg cost.Config) {
-	targetHours := targetMergeTime.Hours()
+func printMergeTimeModelingCallout(breakdown *cost.Breakdown, cfg cost.Config) {
+	targetHours := cfg.TargetMergeTimeHours
 	currentHours := breakdown.PRDuration
 
 	// Calculate hourly rate
@@ -538,15 +540,15 @@ func printMergeTimeModelingCallout(breakdown *cost.Breakdown, targetMergeTime ti
 	// Recalculate delivery delay with target merge time
 	remodelDeliveryDelayCost := hourlyRate * cfg.DeliveryDelayFactor * targetHours
 
-	// Code churn: 40min-1h is too short for meaningful code churn (< 1 day)
+	// Code churn: target time is too short for meaningful code churn (< 1 day)
 	remodelCodeChurnCost := 0.0
 
 	// Automated updates: only applies to PRs open > 1 day
 	remodelAutomatedUpdatesCost := 0.0
 
 	// PR tracking: scales with open time (already minimal for short PRs)
 	remodelPRTrackingCost := 0.0
-	if targetHours >= 1.0 { // Only track PRs open >= 1 hour
+	if targetHours >= 1.0 { // Minimal tracking for PRs open >= 1 hour
 		daysOpen := targetHours / 24.0
 		remodelPRTrackingHours := (cfg.PRTrackingMinutesPerDay / 60.0) * daysOpen
 		remodelPRTrackingCost = remodelPRTrackingHours * hourlyRate

cmd/prcost/repository.go

@@ -16,7 +16,7 @@ import (
 // and extrapolation - all functionality is available to external clients.
 //
 //nolint:revive // argument-limit: acceptable for entry point function
-func analyzeRepository(ctx context.Context, owner, repo string, sampleSize, days int, cfg cost.Config, token, dataSource string, modelMergeTime *time.Duration) error {
+func analyzeRepository(ctx context.Context, owner, repo string, sampleSize, days int, cfg cost.Config, token, dataSource string) error {
 	// Calculate since date
 	since := time.Now().AddDate(0, 0, -days)
 
@@ -105,7 +105,7 @@ func analyzeRepository(ctx context.Context, owner, repo string, sampleSize, days
 	extrapolated := cost.ExtrapolateFromSamples(breakdowns, len(prs), totalAuthors, openPRCount, actualDays, cfg)
 
 	// Display results in itemized format
-	printExtrapolatedResults(fmt.Sprintf("%s/%s", owner, repo), actualDays, &extrapolated, cfg, *modelMergeTime)
+	printExtrapolatedResults(fmt.Sprintf("%s/%s", owner, repo), actualDays, &extrapolated, cfg)
 
 	return nil
 }
@@ -115,7 +115,7 @@ func analyzeRepository(ctx context.Context, owner, repo string, sampleSize, days
 // and extrapolation - all functionality is available to external clients.
 //
 //nolint:revive // argument-limit: acceptable for entry point function
-func analyzeOrganization(ctx context.Context, org string, sampleSize, days int, cfg cost.Config, token, dataSource string, modelMergeTime *time.Duration) error {
+func analyzeOrganization(ctx context.Context, org string, sampleSize, days int, cfg cost.Config, token, dataSource string) error {
 	slog.Info("Fetching PR list from organization")
 
 	// Calculate since date
@@ -207,7 +207,7 @@ func analyzeOrganization(ctx context.Context, org string, sampleSize, days int,
 	extrapolated := cost.ExtrapolateFromSamples(breakdowns, len(prs), totalAuthors, totalOpenPRs, actualDays, cfg)
 
 	// Display results in itemized format
-	printExtrapolatedResults(fmt.Sprintf("%s (organization)", org), actualDays, &extrapolated, cfg, *modelMergeTime)
+	printExtrapolatedResults(fmt.Sprintf("%s (organization)", org), actualDays, &extrapolated, cfg)
 
 	return nil
 }
@@ -278,7 +278,7 @@ func formatTimeUnit(hours float64) string {
 // printExtrapolatedResults displays extrapolated cost breakdown in itemized format.
 //
 //nolint:maintidx,revive // acceptable complexity/length for comprehensive display function
-func printExtrapolatedResults(title string, days int, ext *cost.ExtrapolatedBreakdown, cfg cost.Config, modelMergeTime time.Duration) {
+func printExtrapolatedResults(title string, days int, ext *cost.ExtrapolatedBreakdown, cfg cost.Config) {
 	fmt.Println()
 	fmt.Printf("  %s\n", title)
 	avgOpenTime := formatTimeUnit(ext.AvgPRDurationHours)
@@ -614,11 +614,11 @@ func printExtrapolatedResults(title string, days int, ext *cost.ExtrapolatedBrea
 	fmt.Println()
 
 	// Print extrapolated efficiency score + annual waste
-	printExtrapolatedEfficiency(ext, days, cfg, modelMergeTime)
+	printExtrapolatedEfficiency(ext, days, cfg)
 }
 
 // printExtrapolatedEfficiency prints the workflow efficiency + annual waste section for extrapolated totals.
-func printExtrapolatedEfficiency(ext *cost.ExtrapolatedBreakdown, days int, cfg cost.Config, modelMergeTime time.Duration) {
+func printExtrapolatedEfficiency(ext *cost.ExtrapolatedBreakdown, days int, cfg cost.Config) {
 	// Calculate preventable waste: Code Churn + All Delay Costs + Automated Updates + PR Tracking
 	preventableHours := ext.CodeChurnHours + ext.DeliveryDelayHours + ext.AutomatedUpdatesHours + ext.PRTrackingHours
 	preventableCost := ext.CodeChurnCost + ext.DeliveryDelayCost + ext.AutomatedUpdatesCost + ext.PRTrackingCost
@@ -676,14 +676,14 @@ func printExtrapolatedEfficiency(ext *cost.ExtrapolatedBreakdown, days int, cfg
 	fmt.Println()
 
 	// Print merge time modeling callout if average PR duration exceeds model merge time
-	if ext.AvgPRDurationHours > modelMergeTime.Hours() {
-		printExtrapolatedMergeTimeModelingCallout(ext, days, modelMergeTime, cfg)
+	if ext.AvgPRDurationHours > cfg.TargetMergeTimeHours {
+		printExtrapolatedMergeTimeModelingCallout(ext, days, cfg)
 	}
 }
 
 // printExtrapolatedMergeTimeModelingCallout prints a callout showing potential savings from reduced merge time.
-func printExtrapolatedMergeTimeModelingCallout(ext *cost.ExtrapolatedBreakdown, days int, targetMergeTime time.Duration, cfg cost.Config) {
-	targetHours := targetMergeTime.Hours()
+func printExtrapolatedMergeTimeModelingCallout(ext *cost.ExtrapolatedBreakdown, days int, cfg cost.Config) {
+	targetHours := cfg.TargetMergeTimeHours
 
 	// Calculate hourly rate
 	hourlyRate := (cfg.AnnualSalary * cfg.BenefitsMultiplier) / cfg.HoursPerYear
@@ -702,7 +702,7 @@ func printExtrapolatedMergeTimeModelingCallout(ext *cost.ExtrapolatedBreakdown,
 
 	// PR tracking: scales with open time
 	remodelPRTrackingPerPR := 0.0
-	if targetHours >= 1.0 { // Only track PRs open >= 1 hour
+	if targetHours >= 1.0 { // Minimal tracking for PRs open >= 1 hour
 		daysOpen := targetHours / 24.0
 		remodelPRTrackingHours := (cfg.PRTrackingMinutesPerDay / 60.0) * daysOpen
 		remodelPRTrackingPerPR = remodelPRTrackingHours * hourlyRate

internal/server/static/index.html

@@ -1510,7 +1510,7 @@ <h3>Why calculate PR costs?</h3>
             }
 
             let html = '<div style="margin: 24px 0; padding: 12px 20px; background: linear-gradient(135deg, #f0f4f9 0%, #ffffff 100%); border: 1px solid #0066cc; border-radius: 8px; font-size: 14px; color: #1d1d1f; line-height: 1.6;">';
-            html += '<strong>💡 Merge Time Modeling:</strong> If you lowered your average merge time to 1h, you would save <strong>~' + savingsText + '/yr</strong> in engineering overhead' + throughputText + '.';
+            html += '<strong>💡 Merge Time Modeling:</strong> If you lowered your average merge time to 1.5h, you would save <strong>~' + savingsText + '/yr</strong> in engineering overhead' + throughputText + '.';
             html += '</div>';
             return html;
         }
@@ -2271,16 +2271,16 @@ <h3>Why calculate PR costs?</h3>
                                         html += formatEfficiencyHTML(extEfficiencyPct, extEfficiency.grade, extEfficiency.message, extPreventableCost, extPreventableHours, e.total_cost, e.total_hours, avgPRDurationHours, true, annualWasteCost, annualWasteHours, wasteHoursPerWeek, wasteCostPerWeek, wasteHoursPerAuthorPerWeek, wasteCostPerAuthorPerWeek, totalAuthors, salary, benefitsMultiplier, analysisType, sourceName);
 
                                         // Add R2R callout if enabled, otherwise generic merge time callout
-                                        // Calculate modeled efficiency (with 40min/1h merge time)
-                                        const targetMergeHours = 40 / 60; // 40 minutes in hours
+                                        // Calculate modeled efficiency (with 1.5h merge time)
+                                        const targetMergeHours = 1.5; // 1.5 hours (90 minutes)
                                         const hourlyRate = (salary * benefitsMultiplier) / 2080;
 
                                         // Remodel preventable costs with target merge time
                                         const deliveryDelayFactor = 0.20; // From DefaultConfig
                                         const remodelDeliveryDelayPerPR = hourlyRate * deliveryDelayFactor * targetMergeHours;
                                         const remodelCodeChurnPerPR = 0; // < 1 day, no churn
                                         const remodelAutomatedUpdatesPerPR = 0; // < 1 day, no automated updates
-                                        const remodelPRTrackingPerPR = 0; // < 1 hour, no tracking
+                                        const remodelPRTrackingPerPR = 0; // < 2 hours, minimal tracking
 
                                         const totalPRs = e.total_prs;
                                         const remodelPreventableCost = (remodelDeliveryDelayPerPR + remodelCodeChurnPerPR +

pkg/cost/cost.go

@@ -109,6 +109,11 @@ type Config struct {
 	// - 0.080+ (8%+/week) → 99%+ annual churn - extremely fast-moving, younger companies
 	WeeklyChurnRate float64
 
+	// TargetMergeTimeHours is the target merge time in hours for efficiency modeling (default: 1.5 hours / 90 minutes)
+	// Used to calculate potential savings if merge times were reduced to this target.
+	// This represents a realistic goal for well-optimized PR workflows.
+	TargetMergeTimeHours float64
+
 	// COCOMO configuration for estimating code writing effort
 	COCOMO cocomo.Config
 }
@@ -132,6 +137,7 @@ func DefaultConfig() Config {
 		ReviewInspectionRate:     275.0,                           // 275 LOC/hour (average of optimal 150-400 range)
 		ModificationCostFactor:   0.4,                             // Modified code costs 40% of new code
 		WeeklyChurnRate:          0.0229,                          // 2.29% per week (70% annual, 60th percentile empirical)
+		TargetMergeTimeHours:     1.5,                             // 1.5 hours (90 minutes) target for efficiency modeling
 		COCOMO:                   cocomo.DefaultConfig(),
 	}
 }

pkg/cost/cost_test.go

@@ -1537,7 +1537,7 @@ func TestExtrapolateFromSamplesR2RSavings(t *testing.T) {
 	}
 
 	// For a 3-day PR, there should be significant savings
-	// (R2R targets 40-minute PRs, which would eliminate most delay costs)
+	// (R2R targets 1.5-hour PRs, which would eliminate most delay costs)
 	if result.R2RSavings == 0 {
 		t.Error("Expected positive R2R savings for long-duration PRs")
 	}

pkg/cost/extrapolate.go

@@ -96,7 +96,7 @@ type ExtrapolatedBreakdown struct {
 
 	// R2R cost savings calculation
 	UniqueNonBotUsers int     `json:"unique_non_bot_users"` // Count of unique non-bot users (authors + participants)
-	R2RSavings        float64 `json:"r2r_savings"`          // Annual savings if R2R cuts PR time to 40 minutes
+	R2RSavings        float64 `json:"r2r_savings"`          // Annual savings if R2R cuts PR time to target merge time
 }
 
 // ExtrapolateFromSamples calculates extrapolated cost estimates from a sample
@@ -389,31 +389,31 @@ func ExtrapolateFromSamples(breakdowns []Breakdown, totalPRs, totalAuthors, actu
 	preventableCost := extCodeChurnCost + extDeliveryDelayCost + extAutomatedUpdatesCost + extPRTrackingCost
 	baselineAnnualWaste := preventableCost * (52.0 / (float64(daysInPeriod) / 7.0))
 
-	// Re-model with 40-minute PR merge times
-	// We need to recalculate delivery delay and future costs assuming all PRs take 40 minutes (2/3 hour)
-	const targetMergeTimeHours = 40.0 / 60.0 // 40 minutes in hours
+	// Re-model with target PR merge time from config
+	// We need to recalculate delivery delay and future costs assuming all PRs take the target merge time
+	targetMergeTimeHours := cfg.TargetMergeTimeHours
 
-	// Recalculate delivery delay cost with 40-minute PRs
+	// Recalculate delivery delay cost with target merge time PRs
 	// Delivery delay formula: hourlyRate × deliveryDelayFactor × PR duration
 	var remodelDeliveryDelayCost float64
 	for range breakdowns {
 		remodelDeliveryDelayCost += hourlyRate * cfg.DeliveryDelayFactor * targetMergeTimeHours
 	}
 	extRemodelDeliveryDelayCost := remodelDeliveryDelayCost / samples * multiplier
 
-	// Recalculate code churn with 40-minute PRs
+	// Recalculate code churn with target merge time PRs
 	// Code churn is proportional to PR duration (rework percentage increases with time)
-	// For 40 minutes, rework percentage would be minimal (< 1 day, so ~0%)
-	extRemodelCodeChurnCost := 0.0 // 40 minutes is too short for meaningful code churn
+	// For target merge times < 1 day, rework percentage would be minimal (~0%)
+	extRemodelCodeChurnCost := 0.0 // Target merge time is too short for meaningful code churn
 
 	// Recalculate automated updates cost
 	// Automated updates are calculated based on PR duration
-	// With 40-minute PRs, no bot updates would be needed (happens after 1 day)
-	extRemodelAutomatedUpdatesCost := 0.0 // 40 minutes is too short for automated updates
+	// With target merge time PRs, no bot updates would be needed (happens after 1 day)
+	extRemodelAutomatedUpdatesCost := 0.0 // Target merge time is too short for automated updates
 
 	// Recalculate PR tracking cost
 	// With faster merge times, we'd have fewer open PRs at any given time
-	// Estimate: if current avg is X hours, and we reduce to 40 min, open PRs would be (40min / X hours) of current
+	// Estimate: if current avg is X hours, and we reduce to target, open PRs would be (target / X hours) of current
 	var extRemodelPRTrackingCost float64
 	var currentAvgOpenTime float64
 	if successfulSamples > 0 {