Devin.ai: Your Complete Guide to the World's First AI Software Engineer

You've seen the headlines. You've heard the buzz. And now you're asking the million-dollar question—or in this case, the $500/month question: What is Devin.ai, and should my business be paying attention? The discourse is polarized. On one side, Devin is hailed as the "world's first fully autonomous AI software engineer," a groundbreaking tool poised to redefine the boundaries of software development with AI. On the other, it's met with deep skepticism, fueling concerns about job replacement and critiques of overblown marketing claims.

For a Visionary CTO, this isn't just about a new tool; it's about maintaining a competitive technological edge. For a Strategic CFO, it's a question of measurable Return on Investment (ROI) versus a potentially unpredictable Total Cost of Ownership (TCO). For a Driven Head of Sales, it's about accelerating time-to-market. This is a strategic business decision, not a mere technical curiosity.

Here at Baytech Consulting, our core principles of "Tailored Tech Advantage" and "Rapid Agile Deployment" demand that we look beyond the hype. We believe in harnessing cutting-edge technology, but only when it's grounded in a clear-eyed analysis of its true costs, capabilities, and strategic fit. This guide is our comprehensive, no-nonsense answer to your questions about Devin. We'll dissect what it is, what it costs, where it succeeds, where it fails, and ultimately, help you determine if it has a place in your organization's future.

What Is Devin, Really? Beyond the "AI Software Engineer" Buzzword

To understand Devin, it's essential to look past the marketing tagline and examine its origins, mechanics, and fundamental design philosophy. It represents a significant, and deliberate, departure from the AI coding tools that have become mainstream.

The Origin Story

Devin is the creation of Cognition Labs, a U.S.-based startup that emerged with a formidable pedigree. The ten-member team, led by CEO Scott Wu, includes several individuals with backgrounds in competitive coding, a discipline that hones skills in rapid, algorithmic problem-solving. Backed by a $21 million Series A funding round led by Peter Thiel's Founders Fund, Cognition Labs is not a casual entrant into the AI space; it's a well-capitalized venture with the stated ambition of solving machine reasoning. Devin is their first, and most prominent, step toward that goal.

How It Works: The Autonomous Agent Model

What truly sets Devin apart is its architecture as an autonomous agent. Unlike previous AI tools that assist a developer, Devin is designed to act like a developer. It operates within a self-contained, sandboxed compute environment that includes the three essential tools of any modern software engineer: a shell (command line), a code editor, and a web browser.

The process follows a logical, human-like workflow:

1. Prompt & Plan: A user provides a task in natural language, such as "Build a website that simulates the Game of Life" or "Fix this bug described in this GitHub issue". Devin's "Planner" module then analyzes the request and breaks it down into a detailed, step-by-step plan.
2. Execute & Iterate: Devin begins executing the plan, using its tools as needed. It will use the shell to install dependencies, the code editor to write and modify code, and the browser to search for documentation on unfamiliar APIs or frameworks.
3. Test & Debug: A core feature is its iterative "test-debug-fix" loop. Devin can run tests, read error logs from the console, and then attempt to fix its own mistakes, continuing this cycle until the tests pass.
4. Report & Collaborate: Throughout the process, Devin reports its progress in real-time and can accept feedback from the user. If a user spots an issue or wants to change the approach, they can intervene, and Devin will adjust its plan accordingly.

Key Capabilities

Based on Cognition Labs' demonstrations and documentation, Devin is designed to handle a wide array of software engineering tasks. Its advertised capabilities include:

• End-to-End Application Development: Building and deploying complete applications from scratch, including adding features incrementally based on user requests.
• Autonomous Bug Fixing: Identifying, reproducing, and fixing bugs in existing codebases, even in mature, open-source repositories.
• Learning Unfamiliar Technologies: Reading blog posts and API documentation to learn how to use a new tool or framework without prior training.
• AI Model Training: Setting up the environment and process for fine-tuning its own large language models.
• Real-World Task Completion: Successfully completing freelance coding jobs posted on platforms like Upwork, including tasks involving computer vision models.

The Key Differentiator: Agent vs. Assistant

The most critical concept for any business leader to grasp is the distinction between an AI assistant and an AI agent. This is not just a semantic difference; it's a fundamental shift in the human-AI interaction model and has profound implications for workflow, cost, and risk.

• An AI Assistant (e.g., GitHub Copilot, Amazon CodeWhisperer; see our guide to choosing AI coding tools) works within a developer's environment, typically an Integrated Development Environment (IDE). It augments the developer's actions by suggesting code completions, generating functions, or explaining code blocks. The developer is always in direct control, acting as the driver, with the AI serving as a super-powered navigator.
• An AI Agent (e.g., Devin) is given a high-level goal and is designed to execute the entire workflow to achieve it. It operates more independently, making thousands of decisions along the way. In this model, the human acts more like a manager or a client giving instructions, while the AI attempts to be the driver.

This paradigm shift from augmenting developer tasks to automating entire developer workflows is Devin's core proposition. The potential value is not merely in writing a specific function faster, but in the possibility of offloading and parallelizing entire segments of the development lifecycle. However, this also shifts the nature of risk. With an assistant, the risk is that it might suggest incorrect or inefficient code that a human developer must then catch and fix. With an agent, the risk is that it could spend hours—or even days—of expensive compute time pursuing a fundamentally flawed plan, requiring a different level of human oversight and management skill to prevent.

The Bottom Line: How Much Does Devin Cost?

For any strategic business decision, a clear understanding of cost is paramount. Devin's pricing model is more complex than a simple subscription fee, involving a usage-based component that requires careful management to control expenses.

Devin's Pricing Plans: A Detailed Breakdown

Devin is offered in three primary tiers, each designed for a different scale of use. While a private beta or free version has been mentioned, access is limited, and the main commercial offerings are as follows:

The Core plan offers a low-commitment entry point, but costs can scale quickly with usage. The Team plan provides a bundle of usage credits at a slightly lower per-unit cost and adds crucial features for professional teams, like API access and priority support. The Enterprise plan is for large-scale deployments where security, data privacy (via Virtual Private Cloud deployment), and custom-tuned models are non-negotiable.

Decoding "Agent Compute Units" (ACUs): The Real Cost Driver

The centerpiece of Devin's pricing is the Agent Compute Unit, or ACU. This is Cognition's proprietary, normalized measure of the resources Devin consumes to perform work. Understanding ACUs is the key to understanding Devin's true cost.

What consumes ACUs?

• Actions: The number and complexity of actions Devin takes, including planning, code execution, and browser interactions.
• Resources: Virtual machine time and network bandwidth, though these are typically a small fraction of the total.

What does NOT consume ACUs? This is a critical detail for cost management. Devin does not charge for idle time. Specifically, ACUs are not consumed while:

• Waiting for a user's response in the chat.
• Waiting for a long-running test suite to complete.
• Setting up and cloning repositories.

To make this less abstract, Cognition provides a few benchmarks. For approximately one ACU, Devin can perform a task like:

• Finding an old commit, restoring a feature from it, and modifying its design.
• Investigating a bug, implementing a fix, and ensuring it passes CI tests.
• Creating a simple personal website.

Are There Hidden Costs? The ACU Consumption Black Box

The most significant "hidden cost" of Devin is the potential for unpredictable and rapid ACU consumption. While the price per ACU is transparent, the number of ACUs a given task will require is not. This introduces a level of financial uncertainty that CFOs and budget managers need to be aware of.

Several factors can cause ACU usage to escalate unexpectedly:

• Task Complexity: More complex problems naturally require more planning, execution steps, and debugging loops, all of which consume ACUs.
• Prompt Quality: Vague, ambiguous, or incomplete prompts force Devin to spend more time and resources on context gathering and potentially pursue incorrect paths before being corrected, wasting ACUs.
• Codebase Size: Working within a large, complex codebase requires Devin to process more context, increasing the ACU cost for each action.
• Session Length: Long, meandering sessions with frequent back-and-forth messaging will consume more ACUs than short, well-scoped tasks.

This pricing structure represents a fundamental shift in financial risk compared to traditional SaaS tools. A standard per-seat license like GitHub Copilot offers budget predictability; the cost is fixed regardless of how much or how inefficiently the tool is used. With Devin's usage-based model, the financial risk is transferred to the user. The cost is directly tied to the operational execution and the skill of the human managing the AI. An inefficiently managed session can easily lead to budget overruns. This makes a pilot program to establish internal benchmarks for ACU consumption per task-type an essential prerequisite for any organization considering wider adoption.

Calculating the True Investment: Total Cost of Ownership (TCO)

For a strategic tool with the potential to reshape development workflows, the monthly subscription and usage fees are merely the visible part of the financial iceberg. A comprehensive Total Cost of Ownership (TCO) analysis is essential for understanding the full investment required to successfully integrate a tool like Devin. This moves beyond the sticker price to account for all direct, indirect, and operational costs over the tool's lifecycle.

Direct Costs

These are the most straightforward expenses and are directly tied to acquiring and using the software:

• Subscription Fees: The fixed monthly charge for the Team ($500/month) or a custom negotiated rate for the Enterprise plan.
• ACU Consumption Costs: The variable costs associated with ACU usage. This includes the 250 ACUs bundled with the Team plan and any additional ACUs purchased, either manually or through auto-reload settings.

Indirect (and Often Overlooked) Costs

These are the less obvious but equally significant costs associated with integrating the tool into your organization's people, processes, and technology stack.

• Training & Enablement: Devin requires a new skill set: managing an AI agent. Engineers must learn to think like a manager, breaking down complex problems into clear, unambiguous, and AI-digestible tasks. This includes mastering "defensive prompting"—anticipating where the AI might get confused and providing clarification upfront. This learning curve represents a significant investment in engineering time, which translates directly to cost.
• Integration & Process Change: Devin's primary workflow is Slack-based, which can be a major disruption for development teams accustomed to highly optimized, IDE-centric workflows. The context switching between a local development environment and a Slack chat, coupled with the potential for "slack thread hell," introduces friction and a real productivity cost. Processes for code review, branching strategies, and task assignment may all need to be re-evaluated.
• Security & Compliance Review: For any enterprise, allowing an external AI agent access to proprietary source code is a significant security decision. This necessitates a thorough due diligence process, including security audits, legal reviews of data privacy policies, and ensuring compliance with standards like SOC 2 or GDPR. These activities require time from expensive, specialized personnel.
• Management & Quality Assurance Overhead: This is potentially the largest indirect cost. Independent reviews have highlighted Devin's low success rate on general tasks and its tendency to get stuck on dead-end paths. This means significant human engineering time must be allocated to supervising Devin, reviewing every line of code it produces, correcting its mistakes, and providing the necessary guidance to get it back on track. This is not a "fire and forget" tool; it requires active, skilled management.

To provide a practical framework for evaluating these expenses, the following table outlines a TCO model applicable to Devin and similar AI development tools.

This table provides a hypothetical framework. Actual costs will vary based on team size, usage patterns, and internal labor rates.

What's the Payoff? Analyzing the Return on Investment (ROI) of Devin

After calculating the comprehensive TCO, the next logical question for any business leader is about the return. The narrative around Devin's ROI is sharply divided, presenting both a utopian vision of hyper-productivity and a dystopian reality of frustrating failures. The truth, as is often the case, lies in understanding the context behind these conflicting reports.

The Promised ROI: A Paradigm Shift in Productivity

The official case studies from Cognition Labs paint a compelling picture of transformative ROI. These stories are not just about incremental improvements; they describe order-of-magnitude gains in efficiency and cost savings.

• The Nubank Case Study: This is the flagship success story. The financial services giant was facing a monumental, multi-year project to migrate its core ETL (Extract, Transform, Load) monolith, a task that would have required distributing work across over a thousand engineers. By deploying an "army of Devins" to tackle thousands of repetitive sub-tasks in parallel, Nubank reportedly completed segments of the migration in weeks instead of years. They achieved a

  12x improvement in engineering hours saved and a staggering 20x in cost savings.

• The Ramp and Bilt Case Studies: Other early adopters report similar successes. Ramp used Devin to automate the cleanup of technical debt, such as removing deprecated feature flags and fixing flaky tests, saving thousands of engineering hours and merging up to 80 PRs per week. Bilt, a rewards platform, found that Devin produced the work equivalent of

  10 engineers every week, helping their team ship code 10x faster by overcoming "coder's block" and generating first drafts for new features.

These examples represent the potential upside—the scenario where Devin is applied to an ideal problem at scale, justifying its high cost and delivering a massive return.

The Reality of ROI: A Tool, Not a Silver Bullet

Contrasting sharply with the official narrative are the findings from independent researchers and developers who have put Devin to the test on more general, real-world tasks. Their results suggest that achieving a positive ROI is far from guaranteed.

• Negative Productivity Impact: A surprising study from METR, an AI research lab, found that when experienced open-source developers were given access to AI tools for realistic coding tasks, they actually took 19% longer to complete them compared to working without AI. Intriguingly, the developers perceived that the AI had made them 20% faster, highlighting a dangerous gap between the feeling of productivity and the actual outcome. To avoid these pitfalls and deliver on productivity, explore best practices for adopting AI agents in development.
• Low Success Rates: An analysis by Answer.AI, who spent a month testing Devin, yielded sobering results. Out of 20 tasks attempted, Devin had a success rate of just 15% (3 successes, 14 failures, 3 inconclusive). The report noted that Devin would often get stuck in "technical dead-ends" or "spend days pursuing impossible solutions," turning what should have been a short task into a prolonged and costly failure.

This discrepancy doesn't necessarily mean one side is fabricating results. It points to a more nuanced truth: Devin's performance, and therefore its ROI, is extraordinarily sensitive to the context in which it's used. The massive ROI seen in the case studies was achieved on large-scale, highly structured, and repetitive problems where an initial investment could be made to "teach" and fine-tune Devin for a specific type of sub-task. The poor results from independent tests came from applying Devin to more general, one-off problems without that specialized setup.

A Framework for Maximizing Your Devin ROI

The key takeaway is that ROI is not an inherent feature of Devin itself. It is the result of a disciplined strategy that aligns the tool's unique capabilities with the right problems and management processes. Here are four actionable principles to maximize the potential for a positive return:

1. Start with the Right Tasks: The highest and most reliable ROI comes from deploying Devin on tasks that are "shallow and broad"—a high volume of repetitive, isolated, and junior-engineer-level sub-tasks. This is the exact pattern seen in the successful Nubank and Ramp case studies. Before investing, audit your technical backlog for large-scale projects like code migrations, framework upgrades, or systematic technical debt cleanup that can be broken down into hundreds or thousands of similar, parallelizable chunks.

2. Master the Prompt: Your team's ability to communicate with the AI will directly determine your ROI. Vague prompts lead to wasted ACUs. The best practice is "defensive prompting": anticipate where a junior developer or intern would get confused and provide explicit clarification in the initial prompt. This means telling the agent

   how you want the task done, not just what you want done. Provide clear starting points, links to relevant documentation, and specify important edge cases to consider.

3. Provide Strong Feedback Loops: The "magic" of autonomous agents is their ability to self-correct by iterating against error messages. To enable this, provide Devin with access to your CI/CD pipeline, unit tests, type checkers, and linters. The stronger and faster the feedback loop, the more efficiently Devin can converge on a correct solution without wasting time and ACUs on flawed paths.
4. Embrace the "Human-in-the-Loop" Model: The future of software development with AI is not about full automation but about strategic collaboration. The role of the senior engineer evolves from being the primary doer to being a strategic overseer, a quality controller, and an expert guide for a team of AI agents. This is where the value of a highly skilled team, like the one at Baytech Consulting, becomes even more critical. Success is not just about writing code, but about expertly managing AI to produce enterprise-grade quality, reliability, and security. For a practical approach, see how the Agentic SDLC can transform your development workflow.

Who Is Actually Using Devin? Success Stories vs. Independent Reviews

To make a sound decision, it's crucial to examine both the polished success stories provided by the vendor and the unvarnished experiences of independent testers. This balanced view provides the most realistic picture of Devin's current capabilities.

The Official Showcase: A Look at Key Case Studies

Cognition Labs has highlighted several early adopters who have achieved remarkable results by targeting specific, large-scale problems.

• Nubank: The challenge was an 8-year-old, multi-million-line ETL monolith with deep dependencies, making it a major bottleneck to scaling. The human-led approach was a multi-year project. With Devin, they were able to parallelize the refactoring of over 100,000 datasets, reducing the time per sub-task from an estimated 40 minutes for a human to just 10 minutes for a fine-tuned Devin. This acceleration allowed entire business units to complete their migrations in weeks, not years.
• Ramp: The financial operations platform was struggling with accumulating technical debt, which consumed up to 20% of engineering time. They deployed Devin to build internal automation tools, such as a workflow that removes deprecated feature flags. This complex task, which requires understanding code logic and downstream impacts, was abstracted into a tool where any engineer could simply input a flag name and receive a completed PR. Ramp also automated the first-pass fix for time-sensitive Airflow errors, reducing the average bug-to-PR time to just 8 minutes.
• Bilt: The rewards platform uses Devin to accelerate development and combat "coder's block." Engineers delegate the initial implementation of features to Devin to get a first draft, which they can then refine. This approach has been particularly effective for converting Figma designs into functional frontend code and handling tedious maintenance like Java version upgrades. The results are impressive: over 800 PRs merged since they began, with a greater than 50% acceptance rate for Devin's contributions.

The View from the Trenches: What Independent Testers Found

The experience of independent developers and researchers paints a much more challenging picture, highlighting the tool's immaturity when applied to general-purpose tasks.

• Low Success Rates and Unpredictability: The most widely cited independent analysis, from Answer.AI, concluded that Devin "rarely worked," successfully completing only 3 out of 20 attempted tasks (a 15% success rate). The researchers found it difficult to predict which tasks would succeed, as even simple requests could fail in complex ways.
• Critical Failure Modes: The failures were not minor. The report describes Devin getting stuck in "technical dead-ends," pursuing "impossible solutions for days," and "hallucinating" how to interact with other software tools. For example, when asked to deploy multiple applications to a platform where this was not possible, Devin didn't recognize the constraint and instead invented a flawed process.
• The Upwork Demo Controversy: Cognition's initial demo, which showed Devin completing a job on the freelance platform Upwork, came under intense scrutiny. A detailed analysis by the YouTube channel "Internet of Bugs" alleged that the demo was "borderline deceptive". The analysis claimed that Devin created its own bugs within the project and then fixed them, making it appear as though it was solving pre-existing issues. Furthermore, the claim that Devin "got paid" for the work was described as a "lie," undermining the credibility of the demonstration.

Baytech's Takeaway: Finding the Sweet Spot for Today's Devin

Synthesizing these two conflicting narratives leads to a clear conclusion: Devin is a highly specialized tool, not a general-purpose developer. It excels when applied to highly structured, well-defined, repetitive problems at scale, especially when there's an opportunity to fine-tune its approach over many similar iterations. It struggles significantly with novel, open-ended, or ambiguous tasks where it is left to its own reasoning without a clear, verifiable path to success.

Based on the available evidence, the ideal use cases for Devin in its current state of maturity are:

• High-Volume, Repetitive Migrations & Refactors (Proven by Nubank)
• Systematic Technical Debt Cleanup (Proven by Ramp)
• Initial Prototyping & Boilerplate Scaffolding (Proven by Bilt)
• Investigating CI Failures and Simple, Well-Documented Bug Fixes

The Competitive Landscape: How Devin Stacks Up

Devin did not emerge in a vacuum. It is part of a rapidly evolving ecosystem of AI-powered coding tools. For a CTO evaluating where to invest, it's crucial to understand how Devin's approach, workflow, and pricing compare to the alternatives. The landscape can be broadly divided into two categories: other autonomous agents and IDE-centric assistants.

Category 1: Autonomous Agents

These tools share Devin's ambition of handling entire software development tasks from a high-level prompt.

• Devika: Often positioned as a direct open-source alternative to Devin, Devika aims to replicate its functionality by breaking down instructions, conducting research, and writing code. Being open-source, it offers maximum flexibility and control but requires self-hosting and maintenance, which adds to its TCO. If you're weighing these options, check our strategic assessment of custom versus low-code software options.
• SWE-agent: Another open-source agent, SWE-agent focuses specifically on resolving real GitHub issues. It has achieved a respectable 12.29% resolution rate on the SWE-bench benchmark by using a unique "Agent-Computer Interface" to better interact with files and execute tests.
• MetaGPT: This open-source framework takes a different approach by simulating an entire software company. It assigns different roles (Product Manager, Architect, Engineer, QA) to different AI agents, which then collaborate to produce comprehensive project outputs, including design documents and test plans.

Category 2: IDE-Centric Assistants

These tools are designed to work as a "pair programmer" directly inside a developer's code editor, augmenting their workflow rather than replacing it.

• Cursor: A powerful AI-native IDE built on a fork of VS Code. Cursor's key strength is its deep contextual understanding of the entire codebase. It excels at multi-file edits, refactoring, and answering questions about the code. Its workflow is highly interactive and developer-centric, providing real-time feedback and keeping the human firmly in control. This stands in stark contrast to Devin's asynchronous, hands-off, Slack-based approach. For broader insight, see how smart automation tools are transforming complex industries.
• Amazon CodeWhisperer: An AI coding assistant from AWS that provides real-time code suggestions. Its primary differentiator is its deep integration with the AWS ecosystem, providing intelligent suggestions for AWS APIs and a focus on security by scanning for vulnerabilities and hardcoded credentials.
• Replit Code Repair: Part of the Replit online IDE, this tool focuses on real-time debugging and error correction. It automatically detects and suggests fixes for common errors as the developer codes.

The following table provides an at-a-glance comparison of these key players.

Data sourced from

Under the Hood: What Programming Languages Does Devin Support?

For a tool designed to be a software engineer, language proficiency is a critical factor. While Cognition Labs has not published an exhaustive official list, information from documentation, demonstrations, and third-party analysis indicates that Devin supports a wide range of popular and modern programming languages.

The list of reported languages includes:

• Python
• JavaScript
• Java
• C++
• C#
• Swift
• Rust
• Go
• PHP
• SQL

Beyond this list, Devin's true versatility is demonstrated by its documented capabilities in handling complex code migrations and framework upgrades. For example, its ability to manage a JavaScript to TypeScript migration or an Angular framework upgrade shows a deep understanding of syntax, type systems, and the specific nuances of different technology stacks. This suggests that Devin is not merely trained on a static set of languages but possesses a more fundamental reasoning capability that allows it to learn and adapt to new technologies by processing their documentation—a key feature of its autonomous design. For those in industries where legacy systems meet modern tools, learning from real-world technology upgrades such as the smart energy grid can offer valuable lessons.

Conclusion: Should Your Business Hire Devin?

Devin is a landmark technology and a tangible glimpse into the future of software development. But for most businesses today, it is not a replacement for a skilled engineering team. It is a highly specialized, powerful—and expensive—tool that, when aimed at the right problem, can deliver incredible results. For the wrong problem, it can be a costly waste of time and resources.

The evidence is clear: Devin is groundbreaking but immature. Its potential is undeniable, but its current reliability on general tasks is low. It is a specialist, not a generalist. Its greatest successes have come from tackling high-volume, repetitive tasks like code migrations and systematic refactoring, not from creative, open-ended product development. Most importantly, the human is more critical than ever. The success of an AI agent like Devin is almost entirely dependent on the skill of the human managers who scope its tasks, craft its prompts, and oversee its work. To enhance human oversight and drive better results, draw inspiration from production-grade strategies for managing non-deterministic AI.

Next Steps for Visionary Leaders

Rather than asking "Should we buy Devin?", the more strategic question is "How do we prepare our organization for the era of AI agents?"

1. Conduct a "Devin-Readiness" Audit: Before considering a pilot, analyze your technical backlog and strategic roadmap. Do you have the high-volume, repetitive, and well-defined tasks where a tool like Devin demonstrably excels? If your primary challenges are novel feature development and complex architectural design, your investment may be better placed elsewhere. This audit will also help you identify if your team is ready for agile adoption—a proven framework for structured, iterative improvements when adding AI to development.
2. Invest in AI Management Skills: The most valuable skill in the next decade of software engineering will not be writing code, but effectively managing AI to write code. Start training your senior engineers and tech leads on how to scope problems for AI, how to write effective, unambiguous prompts, and how to build the robust testing and CI/CD feedback loops that these agents require to succeed.
3. Partner with an Expert Guide: Navigating this new landscape is complex. A tool like Devin is just one piece of a broader AI integration strategy. At Baytech Consulting, we partner with businesses like yours to build that strategy, ensuring your technology investments—whether in AI agents or custom applications—are tailored to your unique goals and deliver a measurable return. Our "Tailored Tech Advantage" means we help you choose and implement the right tools for the right job, transforming technological potential into tangible business value.

What's your biggest reservation or hope for AI in your development process? Share your thoughts in the comments below, or reach out to us for a strategic consultation to discuss how your business can prepare for the future of software development.

Further Reading

• How an AI-enabled software product development life cycle will fuel innovation
• (https://moduscreate.com/blog/roi-of-ai-assisted-product-development/)
• (https://builtin.com/articles/human-in-the-loop-evolution)