New to Claude Skills? Learn how to install them →

Egoogle-gemini on GitHub

Effort Estimator

OfficialFree

Quickly estimate implementation effort for issues.

Get this skill

Free · Opens the source repo

What Effort Estimator does

The Effort Estimator is a tool designed for developers and project managers to gauge the implementation effort required to resolve specific issues in a codebase. By analyzing the content of the issue, including its title and body, along with the output from code exploration, this skill provides a structured estimate categorized as SMALL, MEDIUM, or LARGE. This allows teams to prioritize tasks effectively and allocate resources accordingly.

The skill works by parsing the details of the issue and correlating them with the discovered source files, UI components, and test files. This comprehensive analysis enables it to deliver a reasoned estimate that reflects the complexity of the task at hand. For example, it can identify trivial fixes that require minimal time, such as correcting layout bugs or updating documentation, versus more complex tasks that may involve intricate state management or architectural changes.

This tool is particularly useful for teams engaged in agile development practices, where understanding the effort involved in tasks can significantly impact sprint planning and resource allocation. By providing clear estimates, the Effort Estimator helps streamline workflows, making it easier to track progress and manage expectations.

Overall, the Effort Estimator is a valuable addition for any development team looking to enhance their project management capabilities and improve their estimation accuracy.

When to use it

Use this skill when you need to quickly assess the complexity of a task based on issue content and code context.

When not to use it

Avoid using this skill for intermittent or complex issues that are hard to reproduce, as these require more nuanced analysis.

What you can build with it

Sprint Planning

Use the Effort Estimator during sprint planning to gauge the complexity of tasks and allocate resources effectively.

Code Review Preparation

Before a code review, estimate the effort required to address issues raised in pull requests to prioritize fixes.

Task Prioritization

Utilize the skill to categorize tasks based on their estimated effort, helping teams focus on high-impact issues first.

How to install Effort Estimator

View source

1. Install with the skills CLI

npx skills add google-gemini/gemini-cli/effort --agent claude-code

2. Or install it manually

Download the skill folder and drop it into ~/.claude/skills/ for all projects, or .claude/skills/ to scope it to one repo. Restart Claude Code so it picks up the new skill.

Anthropic's agentic coding CLI, and the reference implementation of Agent Skills. Drop a skill folder into ~/.claude/skills and Claude Code loads it automatically whenever a task matches the skill's description. Claude Code docs

Inside SKILL.md

Written by google-gemini

Effort Estimator Instructions

Analyze the issue content (title, body) AND the code exploration output (the discovered source files, coupled UI components, and test files) to estimate the effort required to implement a fix.

JSON Output Format:

{
  "effort_estimate": "SMALL" | "MEDIUM" | "LARGE",
  "effort_reasoning": "Detailed explanation of why this estimate was chosen."
}

Effort Levels:

SMALL (1 day or less):

  • Trivial Logic & Config: Schema updates (Zod), feature flag toggles, adding missing fields to package.json or settings.json.
  • UI/Aesthetic Adjustments: Fixing minor layout bugs in Ink components (e.g., adding flexShrink, correcting padding in a single Box), text color changes.
  • Documentation & Strings: Typos, log message updates, CLI argument descriptions.
  • Localized Bug Fixes: Single-file logic errors, straightforward promise rejections (e.g., wrapping a known failure in a try/catch), simple regex or string parsing fixes.
  • Unhandled Errors with Obvious Fixes: Issues with provided stack traces or obvious offending lines where the root cause and fix are clear. MEDIUM (2-3 days):
  • React/Ink State Management: Complex component lifecycle issues (memory leaks in the UI), terminal redraw flickering, or state synchronization between the CLI's internal input buffer and the interactive React components.
  • Asynchronous Flow & Integration: Resolving complex Promise chains, ERR_STREAM_PREMATURE_CLOSE, debugging IDE companion extensions (VS Code, Android Studio) or resolving hanging HTTP requests/IPC between the CLI and external plugins, timeouts in non-interactive/ACP modes.
  • Tooling & Output Parsers: Modifying how tools parse streaming stdout/stderr buffers, adding new built-in tools that don't require native bindings.
  • Cross-Component & Cross-Package Refactors: Any fix or change that spans across packages/cli and packages/core (such as unifying event handlers, hooks, or UI state across package boundaries). LARGE (3+ days):
  • Platform-Specific Complexities (PTY/Signals): Any issue involving node-pty, child_process.spawn, pseudo-terminal exhaustion (ENXIO), raw mode terminal desyncs, or POSIX signal forwarding (SIGINT/SIGTERM).
  • Core Architecture & Protocols: Refactoring the Scheduler, Agent-to-Agent (A2A) protocol implementation, low-level MCP (Model Context Protocol) transport mechanisms.
  • CI/CD Infrastructure Overhauls: Major redesign of release pipelines or runner execution environments with a large blast radius across production builds.
  • Performance & Memory: Diagnosing massive disk/memory leaks, severe boot time regressions, high-throughput streaming optimizations (e.g., voice streaming pipelines).

Note: Any bug that is described as intermittent, flickering, difficult to reproduce, platform-specific, or requiring cross-environment setups (e.g., involving the VS Code IDE companion, GCA plugin, or Android Studio) MUST NOT be rated as effort/small because of the increased overhead of testing and reproducing.

Frequently asked questions about Effort Estimator

Similar skills