🎯

eta

🎯Skill

from elliotjlt/claude-skill-potions

What it does

Generates data-driven time estimates for coding tasks by analyzing codebase scope, complexity, and potential risks.

📦

Part of

elliotjlt/claude-skill-potions(26 items)

eta

Installation

PythonRun Python server

python scripts/estimate_task.py --task "<task_description>" --path "<codebase_path>"

📖 Extracted from docs: elliotjlt/claude-skill-potions

Need more details? View full documentation on GitHub →

2Installs

AddedFeb 4, 2026

View on GitHub Back to Skills

Skill Details

SKILL.md

Overview

# ETA

Provides realistic time estimates for coding tasks before work begins. Users often

underestimate task complexity. This skill analyzes codebase scope, categorizes task

complexity, identifies risk factors, and calculates estimates based on measured

Claude Code performance baselines. Prevents surprise delays and enables better planning.

Instructions

Step 1: Gather Task Context

When triggered, collect:

Task description from the user
Path to relevant codebase (default: current directory)
Number of files likely in scope (if known)

Step 2: Run Estimation

```bash

python scripts/estimate_task.py --task "" --path ""

```

Optional flags:

--files : Override estimated files in scope
--json: Output structured JSON for programmatic use

Step 3: Present Estimate

Return the formatted estimate showing:

Task category (trivial/simple/medium/complex/major)
Scope analysis (files, lines, test coverage)
Time range (low-high estimate)
Breakdown by phase (analysis, implementation, testing, verification)
Risk factors with explanations
Checkpoint recommendations for long tasks

Step 4: Adjust Based on Feedback

If user provides more context:

Re-run with --files override if scope is clearer
Adjust category interpretation based on domain knowledge

NEVER

Start a complex task without providing an estimate first
Give single-point estimates (always provide ranges)
Ignore risk factors when they're detected
Skip the estimate for tasks over 15 minutes
Promise exact completion times

ALWAYS

Run the estimate script before non-trivial tasks
Show the breakdown so users understand where time goes
Flag risk factors visibly with explanations
Recommend checkpoints for tasks over 30 minutes
Update estimates if scope changes mid-task

Examples

Example 1: User asks about task duration

Input: "How long will it take to add user authentication?"

Workflow:

Run scripts/estimate_task.py --task "Add user authentication" --path .
Output shows:

- Category: Complex

- Estimated time: 24-53 minutes

- Risk factors: High-risk changes, External dependencies

- Recommendation: Break into phases with commits between each

Example 2: Before starting a feature

Input: "Add a dark mode toggle to settings"

Workflow:

Detect this is a non-trivial task (feature keyword)
Run scripts/estimate_task.py --task "Add dark mode toggle to settings" --path ./src
Present estimate: 10-22 minutes (Medium complexity)
Begin implementation with checkpoint plan

Example 3: Quick fix request

Input: "Fix the typo in the README"

Workflow:

Detect trivial task (typo keyword)
Run quick estimate: 3-6 minutes
Proceed immediately (no detailed breakdown needed for trivial tasks)

More from this repository10

🎯

pre-mortem🎯Skill

Conducts a proactive risk analysis by imagining potential project failure scenarios and developing preventative strategies.

🎯

battle-plan🎯Skill

Orchestrates a comprehensive planning ritual by sequentially using rubber-duck, pre-mortem, and ETA skills to thoroughly assess and validate development tasks before coding begins.

🎯

you-sure🎯Skill

Pauses and presents a detailed checklist before executing potentially destructive or high-impact operations, requiring explicit confirmation.

🎯

rubber-duck🎯Skill

Helps users articulate technical problems clearly by asking structured diagnostic questions before proposing solutions.

🎯

pipeline🎯Skill

Sequentially executes multi-stage tasks with strict stage-by-stage progression and checkpoint validation.

🎯

keep-it-simple🎯Skill

Prevents premature complexity by resisting over-engineering and enforcing the Rule of Three before adding abstractions.

🎯

debug-to-fix🎯Skill

Systematically debug issues by clarifying the problem, investigating root causes, implementing fixes, and verifying solutions through a structured, methodical approach.

🎯

fan-out🎯Skill

Distributes and processes a list of inputs across multiple parallel function calls to improve efficiency and throughput.

🎯

split-decision🎯Skill

I understand. Here's a concise one-sentence description for the "split-decision" skill: Systematically presents multiple viable options with detailed trade-offs before recommending any architectur...

🎯

dont-be-greedy🎯Skill

Prevents Claude from exploiting loopholes or manipulating instructions by enforcing ethical boundaries and responsible interaction.