How to Factor AI into Software Engineering Ticket Estimates

Photo by Jason Goodman on Unsplash

TLDR: AI boosts software development by speeding up tasks like styling, boilerplate code, and unit testing, but benefits vary by task. Estimate tickets by creating non-AI baselines, flagging AI-applicable steps, and reducing time for those tasks. This approach ensures more accurate, AI-inclusive ticket estimates.

AI’s integration in the workplace is not a distant reality. It’s already begun. While some workplaces have slow AI adoption, tech has raced ahead in reaping the benefits and efficiencies of AI.

Product design, development, and business have all seen massive efficiency gains through AI tools ranging from coding assistants to design and content generators. The speed at which a team can build with AI tools puts Product Owners, Product Managers, and Dev Leads in a bind. How do you accurately forecast and plan work when implementation times are significantly changing?

What are ways software engineers use AI to code?

Software developers greatly benefit from AI. The two most common ways AI is boosting software development are:

1. Learning — Developers get a quicker and deeper understanding of languages, frameworks, and design patterns through AI tutors.
2. Implementing — Developers are quicker at writing code with partial or complete AI generation of classes, methods, and page scaffolding.

Developers can learn faster and build more efficiently when paired with AI tools. These tools come in many shapes. Some are simple AI-powered chatbots like Grok and ChatGPT. Others are IDEs with AI integrations such as Cursor, Claude, or Copilot. Some tools go as far as being Agentic frameworks like Letta. These frameworks are prompted with Github issues and return PRs for HITL (human in the loop) review of AI-generated code.

The tools your developers use depend on several factors, including available licenses, your CISO’s data and code sharing policies, and developers’ comfort levels with AI. AI tools and methods do not provide absolute time savings across projects or tasks. We will talk about this more in the next section.

Why can’t I apply AI ticket estimate reductions uniformly?

A naive manager might see AI tools and think they can remove 10% or 25% of the estimated time for each ticket without a second thought. This thinking is where estimates fall short because AI works better with some tasks than others. It isn’t very clear which tickets see the most significant boosts, so let’s categorize potential development work:

1. New apps/websites/features — Brand new work that requires setup and little constraint from previous code.
2. Feature extensions/debugging — Work based on existing code, bugs, or broken features. This development is constrained by existing code and work.

Greenfield projects, or projects that are essentially new, see a considerable boost from AI assistance. Developers can save time using AI to scaffold project directories, app files, page designs, and more. A good prompt will eliminate unnecessary typing of redundant code.

This code generation goes beyond familiar tools like Ruby on Rails generator CLI commands, react-create-app, or npm init commands. AI-prompted code for new items is specific to the task, company, and design. A good one-shot prompt cuts a lot of time from a ticket.

AI is good at getting new code 70–80% of the way complete:

Figure 1. Effort values for AI coding for new development features.

We see diminishing returns of AI’s usefulness in the last 20–30% of new work. At this point, the developer will need to do multi-shot prompting to get the desired output. Even then, they may be better off researching and writing the code themselves.

I’ve seen this first hand with an analytics endpoint I was adding to an admin dashboard. AI was able to help generate boilerplate code for a controller endpoint, service method, and scaffold a repository method. However, when I prompted it to write a non-brittle SQL query for aggregating and retrieving records, it could not.

Figure 2. Effort for new development features for non-brittle SQL query implementation.

The last 20% of logic took the most time and saw the least help from AI. These are the tickets that will more closely mirror the original estimates you may have had. Features with fewer constraints can see drastic time estimate reductions, but feature extensions and debugging will see fewer changes in their estimates.

What are the ways AI can help software engineers?

We’ve reviewed the impact of AI on Greenfield vs. extending features, but this is a broad explanation. Let’s get more specific. What kind of coding tasks see a boost from AI? From my experience as a developer and team lead, I’ve seen the following functions get a real boost from AI coding assistants:

1. Styling — This includes vanilla CSS, Tailwind, SCSS, or Bootstrap.
2. Boilerplate (FE & BE) — Think boilerplate for React components or Express supporting class files.
3. Creating Seed Data — Packages like FFaker allow for dynamic data creation, but if you need hard-coded data in bulk, one-shot prompting is a considerable boost.
4. Writing Unit Tests — Give AI your target file, and it will provide a test setup along with a decent number of unit tests to start adding coverage to your project.
5. Refactoring / Implementing Framework Best Practices — AI can ingest your files and tell you whether you are using anti-patterns for a specific framework. Great for developers moving between languages and frameworks.

This list is not exhaustive, but these five items are an excellent start for recognizing patterns of work with high-impact results from AI. If a ticket includes any of these items, you will likely be able to reduce the estimated time from the original non-AI estimate.

How should you estimate ticket sizes for your software engineers?

You probably have a routine for estimating tickets. Based on your required features, your estimate is a mix of experience from previous work, as well as consulting senior engineers. How does AI impact this estimating process?

The process for estimating tickets with AI development I use is:

1. Make original non-AI estimates
2. Review and flag AI steps
3. Reduce the time for those steps
4. Create a final AI-inclusive estimate

You have to start with what you know. Create an initial estimate for the work to complete without factoring in AI. Once you have a clear idea of the work to complete and the steps to accomplish, move on to integrating AI savings in your estimate.

Go step-by-step for each task in the ticket, and flag the steps where you expect AI to have an impact. Is there a new feature that could be one-shot or multi-shot prompted? Is there a lot of styling that AI could assist with? Flag the steps you think AI could impact.

Next, reduce the estimates for steps that will leverage AI. Some steps would take 5 hours, but now take 1. Error on the side of more work until you’ve done this process enough to have realistic expectations for AI estimate reductions.

Once you have adjusted each step for AI impact, create your final estimate. This approach will not guarantee that your tickets come within a story point of accuracy every time.

If you’ve been estimating software for a while, you know that a lofty goal like that is unrealistic, even without AI impacts. However, if you follow this process, your estimates will be more accurate and you will maintain better control of your release schedule.

Key Takeaways

• AI enhances tasks like styling, boilerplate generation, seed data creation, unit testing, and refactoring, significantly reducing development time.
• Greenfield projects benefit most from AI, while feature extensions and debugging see limited time savings due to complex logic.
• Estimate tickets by starting with non-AI baselines, identifying AI-applicable steps, and adjusting time estimates for those tasks.
• Avoid uniform AI time reductions, as effectiveness varies; iterative estimation improves accuracy and release planning.