Introduction
You ask Claude Code: "How long will this chatbot feature take?" It confidently replies: "3-4 weeks for a single engineer." In reality, you'll ship it in a day. This mismatch isn't just annoying—it breaks communication with your product manager and teammates who depend on your work.
The root cause? LLMs are trained on human-written data from before 2022, when humans alone wrote code. So they estimate like a human would, not like an LLM-accelerated developer. Fortunately, you can fix this. This article shows two concrete methods to get accurate, actionable time estimates from your coding agent.
Based on: Why Claude Code Time Estimates Are Poor

Method 1: Base Estimates on Your Historical Data
The most effective technique is to make your agent learn from past tasks. Here's how:
- Track every task in a tool like Linear, Notion, or a simple markdown file. Record start and completion times.
- Create a skill that Claude Code can reference whenever it needs to estimate. The skill contains a summary of past tasks and their actual durations.
Example skill content (stored as estimation-skill.md):
# Time Estimation Skill
## Past Tasks
- Feature A (chatbot integration): 6 hours
- Bug fix B (auth timeout): 1.5 hours
- Feature C (dashboard UI): 4 hours
## Instructions
When asked for an estimate, compare the new task to the most similar past task. Adjust based on complexity. Always output in hours, not weeks.
Then, when you ask for an estimate, Claude Code reads this skill and gives a data-driven answer. No more "3-4 weeks" nonsense.
Why it works: The agent grounds its estimate in real data from your workflow, not generic human averages.

Method 2: Decompose Tasks and Ask for LLM-Specific Estimates
If you don't have historical data, use this approach. Break the task into small subtasks and explicitly ask the LLM to estimate each based on how long an LLM would take, not a human.
Example prompt:
Implement feature X. Break it down into:
- Research
- Implementation part 1
- Implementation part 2
- Testing
For each subtask, estimate the time assuming an LLM is doing the work (with human oversight). Then sum them up.
The LLM knows it can research faster than a human Googling, so it'll give realistic numbers. Smaller tasks are easier to estimate accurately, and the sum is more reliable than a single big guess.
Caveat: Even with these methods, estimates won't be perfect. Unknowns (dependencies, rebases, unexpected bugs) always exist. But you'll be far closer than the default "human-weeks" answer.
Related: Vercel Ships Agent Runs: Debug Your AI Agents via MCP and CLI — learn how to observe and debug your coding agents in production.

Conclusion
LLMs give poor time estimates because they're trained on human data. To fix this:
- Track your tasks and build a skill that lets the agent reference past durations.
- Decompose tasks and ask for LLM-specific estimates per subtask.
These techniques turn vague guesses into actionable numbers, improving communication with your team. As LLMs evolve, estimates will improve naturally, but you don't have to wait—apply these methods today.
Further reading: Bending the Curve: How Meta's Adaptive Ranking Model Serves LLM-Scale AI at Sub-Second Latency — a deep dive into latency optimization for large-scale AI systems.