Estimate Sanity Checks: Ask the Agent What You Forgot

Software estimation is notoriously difficult because developers tend to focus on the happy path of coding while ignoring the operational friction that consumes the most time. An estimate sanity check acts as a rigorous filter to catch these omissions before a sprint begins. By leveraging AI coding agents to look at your proposed plan alongside your actual codebase, you can uncover hidden dependencies and edge cases that a human might miss during a quick planning session.

The Problem With Optimistic Estimation

Most developers estimate based on the time it takes to write the core logic of a feature. If a task involves creating a new API endpoint, the estimate covers the controller and the service layer. However, this narrow focus ignores the surrounding work that actually determines the delivery date.

Crucial elements often left out of initial estimates include:

• Database migration scripts and rollback strategies.
• Updating environment variables across multiple deployment stages.
• Adjusting CI/CD pipelines to handle new build dependencies.
• Writing comprehensive integration tests that mock external services.
• Updating documentation for internal teams or public APIs.
• Refactoring existing code that conflicts with the new implementation.

When these items are ignored, the project suffers from "feature creep" not because the scope changed, but because the original scope was poorly understood. Using an automated approach to verify these assumptions reduces the risk of late-stage surprises.

How to Conduct an Estimate Sanity Check

A sanity check is a structured review process. Instead of just guessing a number, you should break down the task into its smallest components and then ask a neutral party, such as an AI agent, to poke holes in your logic.

1. Defined the Scope: Write down exactly what you think needs to be done.
2. Contextual Review: Provide the agent with access to the relevant files in your repository.
3. Edge Case Discovery: Specifically ask for scenarios where the code might fail.
4. Dependency Mapping: Identify which existing modules will be affected by the change.
5. Buffer Calculation: Add time for non-coding tasks like code reviews and manual QA.

This process transforms estimation from a guessing game into a technical audit. It forces you to look at the codebase as it exists today, rather than how you remember it from last week.

Leveraging AI Agents for Planning Accuracy

AI coding agents are uniquely suited for this task because they can process thousands of lines of code faster than a human can read them. While a developer might forget that a specific utility function is used in ten different places, an agent can quickly map those connections.

In a workspace like Deska, you can run multiple agents side by side to get different perspectives on a single problem. Using tools like Claude Code or Codex CLI within panels allows you to keep your editor and your planning conversation in the same visual field. This reduces the cognitive load of switching between your IDE and a separate chat window.

The Ask Deska assistant can also help manage this workflow by opening the necessary terminals and files for the agent to analyze. Since the environment is local-first, the agent has direct access to your files without you needing to manually upload code to a cloud service. This ensures that the sanity check is based on the most recent version of your work.

Comparison: Traditional Planning vs Agent-Assisted Planning

Traditional planning relies heavily on senior developers' intuition. While valuable, intuition is subjective and varies between team members. Agent-assisted planning provides a consistent baseline by analyzing code and git files to identify exactly which lines will be touched.

Managing the Planning Workspace

A flat list of tasks is rarely enough for a complex project. Developers need to visualize the relationship between different parts of the system. Using an infinite canvas allows you to place your project notes, your code editor, and your agent output in a layout that matches your mental model.

For example, you might have one panel showing the current database schema, another with the new feature requirements, and a third where an agent is generating a list of potential breaking changes. This spatial organization prevents the "tab fatigue" that often occurs when toggle-switching between different pieces of documentation.

If you need to step away from your desk, the Deska mobile app allows you to monitor the progress of long-running agent tasks. Since the devices pair directly with no exposed ports, you can check if an agent has finished its analysis while you are away, maintaining the security of your local environment.

Sanity Check Checklists

Before finalizing any estimate, run through this checklist with your AI agent:

• Are there any hard-coded values in the target files that need to be parameterized?
• Does this change violate any existing architectural patterns in the repo?
• What happens if the external API returns a 500 error or a timeout?
• Is there a more efficient way to query the data that avoids N+1 problems?
• Will this change require a change to the Dockerfile or deployment scripts?

By answering these questions before writing a single line of production code, you avoid the rework that typically kills project timelines.

FAQ: Common Estimation Questions

How to improve software estimation accuracy?

Accuracy improves when you break tasks into units no larger than four hours. Use AI agents to scan your repository for hidden dependencies and always include time for setup, testing, and documentation within the primary estimate.

What is a sanity check in project management?

In a technical context, a sanity check is a brief, intense review of a plan to ensure it is based on reality. It involves verifying that the proposed solution is technically feasible and that no major components of the work have been overlooked.

Should I use AI for coding or planning?

Agente-based tools are effective for both, but their value in planning is often underrated. Using coding agents to audit your plans can prevent bugs before they are even written, saving more time than just using them for syntax completion.

Start Building Smarter Workspaces

Better estimation is a result of better visibility. When you can see your entire workflow, from the agent logs to the terminal output, you make fewer mistakes. Deska provides the environment you need to run these advanced planning recipes securely on your own machine. Download the app today to organize your tools on a single, infinite workspace.

Download Deska