task-estimation

Generate structured task estimates with complexity, token count, and touched files.

1|Updated Dec 30, 2025
One-click install
npx skills add https://github.com/dinogit/motocho --skill task-estimation
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: task-estimation
Source: https://github.com/dinogit/motocho/tree/main/.claude/skills-disabled/task-estimation
Command: npx skills add https://github.com/dinogit/motocho --skill task-estimation

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps teams estimate the scope and effort of non-trivial work before committing to implementation, reducing planning risk and improving alignment.

Core Features & Use Cases

  • Structured estimates: Capture Complexity, Est. tokens, and Files touched to guide planning.
  • Pre-commit planning: Use during feature planning, refactoring, or bug fixes to avoid scope creep.
  • Use Case: When deciding whether a change is small or should be broken into tasks, this Skill provides a clear estimate and recommended plan.

Quick Start

Provide a concise estimation for a proposed change by outlining the scope and requesting Complexity, Est. tokens, and touched Files.

Frequently Asked Questions about task-estimation

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I estimate task scope and effort before starting feature development?

To estimate task scope before feature development, you outline the proposed change and request structured metrics. This generates a precise task estimate capturing Complexity, Est. tokens, and touched Files to guide planning and resource allocation.

What is the best way to plan refactoring work across multiple files?

Planning refactoring work across multiple files requires a structured estimate of complexity and touched components. This skill evaluates the proposed change to output a clear scope assessment, helping you avoid scope creep and allocate resources.

Can I use this to decide if a bug fix should be broken into smaller tasks?

Yes, you can use this to decide if a bug fix should be broken into smaller tasks. By generating a structured estimate of complexity, estimated tokens, and touched files, it provides a clear recommendation on whether a change is small or needs decomposition.

How do I get a complexity estimate for a proposed code change?

To get a complexity estimate for a proposed code change, you provide a concise outline of the scope. The skill then generates a structured estimate detailing the complexity level, estimated tokens, and specific files touched.

Does this approach work for pre-commit planning on non-trivial work?

Yes, this approach works for pre-commit planning on non-trivial work. It applies to feature development, refactoring, and bug fixes, capturing scope metrics to reduce planning risk and improve team alignment before implementation.