“We can build this in 1 hour with AI” is an implementation estimate, not a product argument. What a feature costs after the hour, a worked 12-month example, and how to say no without slowing the team.

The cost of building features with AI has collapsed for the first version, but most of what a feature costs arrives after the build: review, security, testing, support, maintenance, and the roadmap attention it takes from other bets. So "we can build this in 1 hour with AI" is an implementation estimate, not a product argument. It proves a prototype is cheap. It doesn't prove the feature is.

Short answer: no, it isn't a good reason on its own. It is a good reason to run a cheap test, if the test answers a real question and has an owner and an end date. The job is to move the conversation from build time to the full cost of owning the result.

Key takeaways

  • Maintenance was already the biggest line before AI. In Stripe's 2018 survey, developers estimated that 17.3 hours of a 41.1-hour week went on maintenance work such as debugging, refactoring and fixing bad code (Stripe, 2018).
  • AI-generated code still needs checking: 66% of developers in the 2025 Stack Overflow survey named "almost right, but not quite" answers as their top frustration, and 45.2% said debugging AI code takes longer (Stack Overflow, 2025).
  • Veracode found AI-generated code introduced risky security flaws in 45% of its tests across more than 100 models (Veracode, 2025).
  • AI speeds up teams but still strains stability. DORA's 2025 research found 90% of respondents use AI at work, and AI adoption still has a negative relationship with software delivery stability (Google Cloud, 2025).
  • In the illustrative example below, a feature built in 1 hour costs about 53 hours in its first year.

Is "we can build this in 1 hour with AI" a good product argument?

Only as evidence that a low-cost probe is possible. It says nothing about whether the problem matters, whether the solution will change behaviour, or whether the team should own the result in production.

The argument isn't new; AI just made it louder. In 2013, Intercom's Des Traynor listed quick-to-build among the common bad reasons teams give for adding features, alongside a competitor having it and a senior person wanting it. His point was that a quick estimate hides complexity: "there are no small changes" (Intercom, 2013).

What changed is the friction. Teams used to reject ideas partly because implementation was visibly expensive: a week of engineering or a risky migration created a natural pause. AI-assisted development removes much of that pause. The new failure mode isn't only building the wrong thing slowly. It is building the wrong thing quickly, then mistaking the existence of software for evidence that the bet was good.

What is the full cost of building features with AI?

A one-hour estimate covers one line of a long bill. Here is the rest, with what the evidence says about each line.

Cost line What it includes What the evidence says
Review and correction Reading, fixing and re-prompting generated code 66% of developers cite "almost right" AI output as the top frustration; 45.2% say debugging AI code takes longer (Stack Overflow, 2025)
Security and permissions Auth, data access, input handling AI code introduced risky flaws in 45% of Veracode's tests (Veracode, 2025)
Testing and release Tests, QA, rollout, rollback Delivery stability fell as AI adoption rose in DORA's 2024 data (Google Cloud, 2024)
Documentation and support Help articles, tickets, onboarding changes Every visible feature adds to what users must learn and support must explain
Maintenance Bug fixes, dependency and API changes, refactoring Developers estimated 17.3 of 41.1 weekly hours go on maintenance (Stripe, 2018)
Product complexity Interface clutter, edge cases, configuration Optional features still show up elsewhere in the product (Intercom, 2013)
Opportunity cost The bet you didn't test, the review time you used up In Pendo's data, 12% of features drive 80% of daily usage (Pendo, 2019)
Removal Migrating users off it if it fails Rarely planned, so rarely cheap

"Cheap to build" is not the same as "cheap to own". That is why the one-hour claim can be technically true and still a poor reason to say yes.

How much does it cost to maintain a feature?

More than the build, almost always. Stripe's Developer Coefficient report, which surveyed thousands of executives and developers across six countries, found developers estimating that 17.3 hours of an average 41.1-hour week go on maintenance: dealing with bad code and errors, debugging, refactoring and modifying. That is about 42% of the week. They put a separate 13.5 hours a week on technical debt, and Stripe estimated the opportunity cost of bad code at about $85 billion a year (Stripe, 2018). These are survey estimates, not time logs, but the direction is clear: code is cheap to add and expensive to keep.

AI tools change how fast code accumulates. GitClear's analysis of 211 million changed lines from 2020 to 2024 found copy-pasted lines rising from 8.3% to 12.3% of changes between 2021 and 2024, while lines moved during refactoring fell from 25% to under 10% (GitClear, 2025). More duplication and less consolidation is how maintenance bills grow.

Why AI features cost even more to keep

If the feature itself uses AI, add a second layer. D. Sculley and colleagues argued in 2015 that machine learning lets teams build useful systems quickly, but that it is dangerous to treat those quick wins as free: real-world ML systems commonly incur massive ongoing maintenance costs (Sculley et al., NIPS 2015). Their risk list maps straight onto today's AI features:

  • Data dependencies: the feature breaks when the data it reads changes shape.
  • Hidden feedback loops: the feature's output changes the behaviour it learns from.
  • Undeclared consumers: other parts of the product start relying on the output.
  • Changes in the external world: a model update or provider change shifts behaviour without a code change.

Each one needs evaluation, monitoring, a fallback and someone who owns the result. None of that fits in an hour. The AI evaluation framework covers what that ownership involves.

What is the opportunity cost of a "cheap" feature?

Opportunity cost is what the team gives up by spending attention here instead of on the next-best bet. With AI, the scarce resource is rarely typing time. It is:

  • Review capacity. Every generated feature needs a careful reader, and senior reviewers are the bottleneck.
  • Roadmap attention. Each feature adds discussions, status updates and edge-case decisions.
  • User attention. Every visible option makes the product slightly harder to learn.
  • Learning time. An hour spent building the wrong thing is also an hour not spent testing the riskiest assumption.

The base rates are not in a "cheap" feature's favour. Pendo's 2019 study of 615 software subscriptions found 80% of features rarely or never used, with 12% of features generating 80% of daily usage (Pendo, 2019). Faster building raises the number of features per quarter; it doesn't change the odds that each one matters. Our analysis of why 80% of features go unused covers what that study did and didn't measure.

Worked example: what a "1-hour" feature costs in year one

Say a 6-person B2B SaaS team builds a "weekly Slack digest" feature with an AI coding tool in one hour. The team and every number below are illustrative, chosen to be modest.

Cost line Year-one estimate Hours
Build with AI One session 1
Review and correct generated code Two reviewers, several passes 6
Security and permissions review Workspace-level access, Slack scopes 4
Tests and QA Edge cases: empty weeks, time zones 3
Docs, help article, release note One of each 2
Support 3 tickets a month × 20 minutes × 12 months 12
Maintenance 1 hour a month for API and dependency changes 12
One incident and fix Digest sent to the wrong channel 6
Planning and discussion 3 discussions × 5 people × 30 minutes 7.5
Total 53.5

The feature that cost one hour costs about 53 hours in its first year, before counting what the team didn't do with that time. That year-one figure is the cost of building features with AI that a roadmap should weigh, not the 1. That doesn't make it a bad feature. If the digest measurably keeps accounts active, 53 hours is cheap. The point is to compare the value against 53 hours.

How do you say no without becoming the "slow PM"?

A strong no is not a veto. It is a decision that can be inspected, challenged and revisited. Use five moves.

1. Name the decision

Avoid "this is probably not worth it." Say "we are not committing this to the production roadmap yet," or "we are parking this until we have evidence that this workflow is a repeated problem." A named decision is easier to discuss than a feeling.

2. Separate the signal from the story

  • "A customer asked for an export" is a signal.
  • "Three customers in the same workflow described the same blocked job" is stronger evidence.
  • "An AI assistant suggested an export feature" is not customer evidence.
  • "A competitor has an export feature" is market context, not proof of fit.

Keep the source attached. A plausible explanation is not an observed problem.

3. State a falsifiable hypothesis

If we give [specific user] [specific capability] in [specific context], then [observable behaviour] will change because [reason supported by evidence]. We will continue if [success condition]. We will narrow or stop if [failure condition] by [review date].

An AI-generated brief can draft this sentence. The team still has to decide whether it believes the sentence enough to test it. The AI product brief as a contract shows how to hold a draft to that standard.

4. Price the full bet

Ask who owns the result, who reviews its behaviour, what happens when it is wrong, what support load it creates, whether it's reversible, what data it touches, and whether you're prepared to operate it if it works. For AI features, add evaluation, fallback behaviour, abuse cases and human escalation. The implementation can take an hour while the ownership lasts for years. Use the cost table above as the checklist.

5. Give the team a next move

A no without a next move feels like bureaucracy. Offer one of four paths:

  • Learn: speak to users or observe the workflow.
  • Narrow: test one segment, trigger or job.
  • Probe: build a disposable prototype with an expiry date.
  • Park: record the idea and why it isn't active, in your decision log.

The next move should be smaller than the commitment being avoided. If the harder problem is keeping a stakeholder's trust while you decline, see how PMs say no without killing trust.

When is "we can build it in one hour" a valid argument?

When the team is explicit that it is running a probe, not making a product commitment. Use the argument when:

  • the test has one clear question and a defined audience;
  • the output is disposable or safely isolated, behind a flag or outside production;
  • the experiment has an expiry date and someone owns the review;
  • success and failure are defined before the build;
  • no customer or production promise is implied.

In that context, speed is a learning advantage, and refusing to test is the expensive choice. Ron Kohavi and Stefan Thomke describe a Bing idea to change how ad headlines were shown. It needed a few days of engineering, was ranked low priority, and sat untested for more than six months. A simple A/B test then showed about 12% more revenue, worth over $100 million a year in the US (HBR, 2017).

The argument becomes weak when it is used to skip problem discovery, prioritisation, safety review or ownership. If the prototype is likely to become permanent, judge it by the one-way vs two-way door test before it ships.

A decision template for AI-assisted teams

Copy this into the next roadmap discussion:

Field Question
Decision What exactly are we saying yes or no to?
User and job Who is trying to do what?
Evidence Which sources show this is a real problem?
Assumption What are we not yet sure about?
Hypothesis What behaviour or outcome should change?
Smallest test What is the least expensive way to learn?
Cost to own (12 months) Review, security, support, maintenance, attention: roughly how many hours?
Success What result earns the next investment?
Failure What result makes us narrow, pause or stop?
Ownership Who reviews the result and owns the consequences?
Expiry and removal When will we revisit it, and how would we remove it?
Non-goals What are we explicitly not building?

This isn't process for its own sake. It is a boundary around the team's attention.

What does the AI development research actually imply?

The research supports neither extreme: "AI changes nothing" or "AI makes product judgement unnecessary."

DORA's 2024 research found that a 25% increase in AI adoption was associated with 7.5% better documentation quality, 3.4% better code quality and 3.1% faster code review, but that delivery throughput fell an estimated 1.5% and delivery stability 7.2% as adoption rose (Google Cloud, 2024). By 2025, with nearly 5,000 respondents, DORA saw a positive relationship with throughput, but AI adoption was still negatively related to stability. Its summary: AI doesn't fix a team, it amplifies what is already there (Google Cloud, 2025).

The product response is not to stop using AI. The cost of building features with AI fell; the cost of deciding badly didn't. Make the evidence and the decision loop as fast as the build. For the full speed evidence, including the METR trials, see AI coding productivity: what the 2026 data shows.

Common mistakes

  • Comparing the build hour with the value. Compare the year-one cost with the value instead.
  • Using cost as a veto. Some cheap probes are the best use of a week. Price the bet, then decide.
  • Letting the prototype become the product. Without an expiry date, a demo quietly turns into a support obligation.
  • Counting AI suggestions as evidence. A model proposing a feature is not a customer asking for one.
  • No removal plan. If you can't say how you'd remove it, you haven't priced it.

Where Specky fits

Specky keeps the chain from signal to decision visible. Customer calls, feedback, support conversations and analytics land in the Product Graph, so when someone says "we can build it in an hour," the team can check which evidence supports the problem. Decisions go into the Decision Log with their rationale, PRDs carry inline citations to the evidence, and after launch you can check whether the bet worked. The AI drafts and connects; people decide and own the outcome.

Frequently asked questions

Is "we can build this in 1 hour with AI" still a good product argument?

Only as evidence that a cheap probe is possible. It doesn't show that the problem matters, that the solution will work, or that the team should support the feature in production. Treat it as a reason to run a bounded test with an owner and expiry date, and price the cost of owning the result separately.

How much does it cost to maintain a software feature?

There is no universal figure, but maintenance usually outweighs the build. In Stripe's 2018 survey, developers estimated 17.3 of a 41.1-hour week, about 42%, goes on maintenance work. A practical habit is to estimate year-one hours for review, security, support, upkeep and discussion; in our illustrative example that came to about 53 hours for a one-hour build.

What is the opportunity cost of building a feature?

It is the value of the best alternative the team gave up: the riskier assumption not tested, the review time used elsewhere, the user attention spent on a new option. With AI, the scarce resource is rarely coding time; it is review capacity, roadmap attention and learning time. Pendo's finding that 12% of features drive 80% of usage shows why that trade matters.

Should teams avoid building prototypes with AI?

No. Use AI to build prototypes when the prototype answers a clear question. Give it an audience, an owner, an expiry date and a review rule so it doesn't quietly become a permanent promise. Cheap tests often beat long debates, as Bing's six-month-old headline idea showed when a simple A/B test lifted revenue about 12%.

What should product teams measure instead of AI build speed?

Measure learning and outcomes: assumptions validated or rejected, user behaviour, quality, delivery stability, adoption, retention, support load, and the business metric the bet was meant to move. DORA's research shows speed and stability can move in opposite directions, so code volume and build time alone are not product progress.

Sources

  1. Stripe — The Developer Coefficient (2018)
  2. D. Sculley et al., NIPS — Hidden Technical Debt in Machine Learning Systems (2015)
  3. Google Cloud — Highlights from the 10th DORA report (2024)
  4. Google Cloud — Announcing the 2025 DORA Report: State of AI-assisted Software Development (2025)
  5. Stack Overflow — 2025 Developer Survey: AI (2025)
  6. GitClear — AI Copilot Code Quality: 2025 research (2025)
  7. Veracode — GenAI Code Security Report, October 2025 update (2025)
  8. Des Traynor, Intercom — Product strategy means saying no (2013)
  9. Pendo — The 2019 Feature Adoption Report (2019)
  10. Ron Kohavi and Stefan Thomke, Harvard Business Review — The Surprising Power of Online Experiments (2017)

This story was originally published on 15 October 2026 at https://www.specky.space/blog/how-to-say-no-product-decisions-we-can-build-this-in-1-hour-with-ai.