<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Fedor Novikov on Medium]]></title>
        <description><![CDATA[Stories by Fedor Novikov on Medium]]></description>
        <link>https://medium.com/@novikovfedor?source=rss-fe6591673721------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*24b9YmsYBUKlvl5Sa2keNg.png</url>
            <title>Stories by Fedor Novikov on Medium</title>
            <link>https://medium.com/@novikovfedor?source=rss-fe6591673721------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 06:02:27 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@novikovfedor/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[AI-Prototyping: Reality Check]]></title>
            <link>https://medium.com/bolt-labs/ai-prototyping-reality-check-27a8a4d1dcbd?source=rss-fe6591673721------2</link>
            <guid isPermaLink="false">https://medium.com/p/27a8a4d1dcbd</guid>
            <category><![CDATA[pmo]]></category>
            <category><![CDATA[ai-projects]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[ai-prototyping]]></category>
            <category><![CDATA[project-management]]></category>
            <dc:creator><![CDATA[Fedor Novikov]]></dc:creator>
            <pubDate>Wed, 17 Jun 2026 07:37:41 GMT</pubDate>
            <atom:updated>2026-06-17T07:37:41.701Z</atom:updated>
            <content:encoded><![CDATA[<p>Speed, Strategy, Hype, Benefits, Risks</p><p><em>Written by Fedor Novikov, Engineering Manager at Bolt.</em></p><h3>Introduction</h3><p>In this article, <strong>AI-prototyping</strong> refers to creating a product-like artefact, either fully or mostly, using artificial intelligence, while intentionally keeping human build time to a minimum. The artefact can be a website, mobile app, service flow, dashboard, internal tool, or design mockup, or technically anything else.</p><p>A concept that once required long documents, several meetings, and multiple alignment loops can now become a clickable flow, a dashboard, a service mockup, or an “almost-MVP” in hours or days. That is the promise: shorter learning loops, clearer conversations, and earlier alignment around something people can actually use, test, and challenge [2][3]. This is the exciting part of AI in product development: it helps teams compress context.</p><p>AI is changing the product lifecycle in a simple but powerful way:<strong> it makes ideas visible earlier. But every compression has a cost.</strong></p><p>Very few would argue against making ideas visible faster. But teams still need to follow fundamental product and project management practices to avoid drowning in endless prototypes while never delivering solutions that actually solve real problems. For instance, a polished demo can create the illusion of progress before the team has validated the problem itself, or a smooth user flow can generate confidence long before the architecture, data assumptions, security model, ownership, or transition path are properly understood.</p><p>The goal is not to sell AI prototyping as magic or dismiss it as hype. The goal is to understand what changes when the creation of artefacts becomes dramatically cheaper.</p><h3>What this article examines</h3><p>The main question is not whether AI can help teams move faster. It clearly can. The more useful question is not how fast <strong>AI can generate artefacts</strong>, but <strong>how teams should evaluate, validate, and evolve them afterwards.</strong></p><p>To answer that, this article compares classical project and product lifecycle thinking [1] with AI-driven development patterns, with a specific focus on AI prototyping. We will look at where AI genuinely helps: discovery, exploration, alignment, and earlier learning. We will also examine areas where it can lead to issues, including false confidence, weak validation, governance drift, security risks, high rewrite costs, and the challenging transition from prototype to MVP and V1.</p><p>Let’s explore that through lifecycle theory, public examples, and practical delivery experience.</p><h3>Key findings</h3><p>The article intentionally starts with a summary to provide an AI-like experience — results first, while the research and deeper reasoning come later. The practical outcomes should be visible immediately, so the key takeaways and recommended actions are presented upfront.</p><p>The central argument is: <strong>AI-generated outcomes are not product evidence until humans validate them. </strong>Without sufficient validation, there is a significant risk of having to rebuild the solution later. AI prototyping can improve alignment and accelerate learning, but only when validation, review discipline, and transition logic keep pace with the speed of artefact creation.</p><p>Let me give an example around the central idea — what could happen to traditional product development phases when we use an AI-based approach for prototyping, MVP development, or assisted delivery. A full overview comes later in the “Applied: Product readiness comparison with and without AI” section.</p><p>Here is an artificial illustrative example of five ways to work with AI across the classical development phases (by “risk” here, we mean the possibility that the project will not be delivered on time):</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*i03F17e0pBJfH7pG6Gm1Xw.png" /></figure><p>This example is intentionally simplified, but it illustrates the core tradeoff. AI prototyping can absolutely help a team reach a prototype, or even an MVP-like artefact, much faster. However, the <strong>saved time often returns later as rewrite cost</strong>, hardening work, or delivery risk. In that case, the short-term speed is not a real win — it is borrowed time.</p><p>The exact numbers should not be treated as a benchmark. They are a directional model based on public sources and delivery experience. To avoid these common pitfalls, the next sections separate what AI prototyping genuinely helps with from what can be misleading, and then outline common practices that build on these ideas.</p><h4>AI prototyping useful</h4><p>The clearest wins show up in three patterns.</p><ul><li><strong>Shared understanding, faster.</strong> A visible demo gives teams something concrete to respond to, reducing abstract debate and helping stakeholders align around a single version of the idea.</li><li><strong>Cheaper exploration before commitment</strong>. AI prototypes make it easier to compare several directions before the organisation locks into one path. This is especially useful when the main uncertainty is about flows, comprehension, usability, or stakeholder expectations.</li><li><strong>Earlier learning, not automatic readiness</strong>. The main value is not just speed; it’s learning before decisions become expensive to change. AI can help teams move faster toward a prototype or MVP [6], but it does not remove the lifecycle work needed for a trustworthy V1: validation, governance, security, integration, and ownership [1].</li></ul><h4>AI prototyping pitfalls</h4><p>The most common pitfalls fall into four patterns.</p><ul><li><strong>Convincing demo, weak evidence</strong>. Polished output can make unresolved problems look solved. A showcase may start to be treated as real product progress, even when it only proves that the idea can be convincingly demonstrated [2].</li><li><strong>Fast solution, wrong problem</strong>. AI can help teams move quickly, but speed does not prove that the problem is worth solving. Without validation, teams may only accelerate toward a better-looking mistake.</li><li><strong>Hidden transition cost</strong>. AI-generated prototypes often look further along than they really are. If the artefact was optimised for demo quality, later rewrites or hardening work should be expected, not treated as a surprise [7].</li><li><strong>Governance and security drift.</strong> Cheap artefacts can bypass ownership, review gates, evidence thresholds, and security checks while still looking credible. Weak sandboxing, real data usage, or overly permissive tools can turn a fast demo into a real organisational risk [8][9].</li></ul><p>The answer is not to prototype less, but to prototype with stronger discipline.</p><h4>Practical guardrails for AI prototyping</h4><p>Up to here, the article has taken several shortcuts — jumping straight from the problem to the solution to the risks, as we’re following an AI-like experience in an article. The section below slows down and turns those quick answers into a concrete operating model. Best practices help build a stronger operating model over AI prototypes: prototype intentionally, learn early, and keep a clear boundary between an exploratory artefact and a real product.</p><p>The practices below turn the risks above into a practical operating model.</p><ol><li><strong>Start with the problem, not the prototype<br>Recommended practice:</strong> Confirm that the underlying problem is worth solving before building AI functionality around it. For serious prototypes, attach a short problem statement: who it is for, what problem it addresses, what success would look like, what constraints exist, and which assumptions remain open [3][6].<br><strong>Why it matters:</strong> Fast prototyping is still a waste if the idea itself is weak. A clear problem statement keeps the team from using AI speed to rush in the wrong direction.</li><li><strong>Use prototypes to explore, not to anchor too early<br>Recommended practice:</strong> When the solution space is still open, compare several directions or run a short problem-framing discussion before committing to the first attractive prototype [3].<br><strong>Why it matters:</strong> AI makes the first convincing option cheap to generate, but that option can quietly become the default answer before the team has tested alternatives.</li><li><strong>Assign one owner end-to-end<br>Recommended practice:</strong> One person should own the story from prototype to transition decision: what was tested, what was learned, what happens next, and who needs to review it [1][4].<br><strong>Why it matters:</strong> Shared excitement does not automatically create accountability. Without a clear owner, a prototype can easily become a future misunderstanding in a nicer outfit.</li><li><strong>Keep the prototype connected to a decision record<br>Recommended practice:</strong> Pair important prototypes with a PRD (product requirements document), decision note, or shared feedback document. Keep a single source of truth for comments, assumptions, scope, trade-offs, and next steps [3][4].<br><strong>Why it matters:</strong> A prototype can show how something might work, but it usually does not explain why a direction was chosen or what constraints shaped the decision.</li><li><strong>Label the artefact honestly and keep lifecycle boundaries clear<br>Recommended practice:</strong> Call the artefact a prototype, demo, pilot, MVP, or V1 only if that label is actually true. Treat prototypes as representations of ideas, not product decisions by themselves [3][5]. Use prototypes to explore and explain; use MVPs to test value under real constraints; treat V1 as a stronger production commitment around reliability, maintainability, security, monitoring, and support [5][6].<br><strong>Why it matters:</strong> Most confusion starts when a persuasive showcase is described as product progress. A prototype can look impressive without being operationally meaningful.</li><li><strong>Use safe demo conditions (no real data by default, limited permissions)<br>Recommended practice:</strong> Avoid real data by default, limit permissions, and keep demo environments clearly separated from production. Do not hide manual work behind apparent automation unless the team explicitly labels it as staged or simulated [8][9][12].<br><strong>Why it matters:</strong> A demo can still create legal, privacy, trust, or commercial risk if it looks more real than it actually is.</li><li><strong>Review before broad exposure<br>Recommended practice:</strong> Run the right level of product, design, engineering, security, and data review before showing the artefact widely. The review should be proportional, not bureaucratic [1][4][8].<br><strong>Why it matters:</strong> Early excitement should not outrun basic sanity checks. A polished demo can influence decisions before the team has verified what it actually proves.</li><li><strong>Decide the transition path early: discard, rewrite, or evolve<br>Recommended practice:</strong> Be explicit about whether the prototype is expected to be discarded, rewritten, or evolved. Treat rewrite or hardening as a normal transition cost, not as an embarrassing surprise [5][7][10].<br><strong>Why it matters:</strong> Teams handle handoffs better when they don’t pretend every prototype is reusable. Many AI-generated prototypes are optimised for speed and demo quality, not for long-term durability.</li><li><strong>Price the real cost and timebox the effort<br>Recommended practice:</strong> Count token spend, creator time, reviewer time, stakeholder time, rewrite cost, and future support cost. Timebox prototype iterations so the team does not keep polishing a demo that should either become a validated next step or be intentionally dropped [3][7][11].<br><strong>Why it matters:</strong> Cheap generation is not the same as cheap ownership. Without limits, AI prototyping can create the feeling of progress while delaying the harder commitment decision.</li></ol><p>One distinction deserves extra emphasis: a prototype is not an MVP. A prototype is usually a showcase or demo artefact. Its job is to make an idea visible, provoke a reaction, or test comprehension. An MVP is already a commitment to learning about the product. It has to survive real use well enough to generate validated learning under actual constraints.</p><p><strong>An AI prototype is useful when it improves learning and decision-making. It becomes dangerous when it starts to replace decisions.</strong></p><h3>Research</h3><p>This section is meant to show that the article’s main arguments about AI prototyping, prototype-to-product transition, and hidden delivery risk are grounded in established product, project, and governance thinking rather than only opinion.</p><p>While I was writing this article, Uber released a related overview of AI prototyping [3], which influenced how I framed it. Their article captures the positive side very well: It opens with a strong example of how two hours of prototyping unblocked four weeks of discussion, and then shows how AI prototypes supported exploration, alignment, and clearer MVP scoping within Uber.</p><p>I genuinely appreciate that contribution, because it gives a concrete industry example of why AI prototyping is attractive. A reader can easily stop after the first optimistic examples and walk away with a simplified conclusion: “If it worked at Uber, we can safely prototype everything with AI too.” But the harder lesson starts after the demo becomes convincing.</p><p>Uber’s article does mention important caveats: prototypes do not replace PRDs (Product Requirements Document), prototype-first is not suitable for every situation, and production still requires rigour. This article starts from the same observation but spends more time on follow-up questions that can be missed when the success story is too compelling: governance [4], prototype-to-product transition [5], security, data trust, and the distinction between a persuasive artefact and validated product progress.</p><p>The reasoning below draws on a few source families. For lifecycle and governance, it uses PMBOK [1], PRINCE2 [4], Stage-Gate [10], and Bolt PMO practices. For discovery and the prototype-versus-product boundary, it uses Lean Startup [6] and SVPG [5] frameworks. For design quality, transition cost, and operational risk, it leans on NN/g [2], Google SRE [11], Martin Fowler [7], NIST [8], FTC [12], and related public guidance. The section is organised as a small set of theses, so the evidence remains readable rather than turning into a long bibliography.</p><h4>Thesis 1: Classical project lifecycles define the baseline that AI prototyping compresses</h4><p>Before discussing what AI changes, it helps to name what already exists. The standard project and product lifecycle, documented across PMBOK [1], PRINCE2 [4], ISO 21502 [13], and the <a href="https://www.apm.org.uk/media/sg0mg1d1/guide-to-lifecycle-models.pdf">APM/INCOSE lifecycle guide</a> [14], follows a recognisable sequence of phases. The terminology varies between frameworks, but the underlying shape is stable:</p><p>Initiation -&gt; Requirements -&gt; Design -&gt; Development -&gt; Testing -&gt; Deployment -&gt; Monitoring -&gt; Closure</p><p>Each phase carries specific responsibilities: initiation defines the business case and authorises the work; requirements capture what the system must do; design translates requirements into architecture; development builds it; testing validates it; deployment releases it; monitoring tracks it in production; and closure formalises lessons learned and handoff.</p><p><strong>This lifecycle has existed for decades because it solves a real coordination problem</strong>. Large teams working on complex systems need shared checkpoints, evidence gates, and clear ownership transitions. AI prototyping does not remove this lifecycle. It compresses certain phases, specifically design and development, while leaving the rest — initiation, monitoring, and closure — largely untouched.</p><p>The table below maps each lifecycle phase against what AI can realistically accelerate and what still requires human judgment. The Low / Medium / High ratings are a qualitative synthesis of NN/g [2], the Uber AI prototyping report [3], PMBOK phase definitions [1], and the author’s delivery experience. They are directional, not measured.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cl5KLeibtttnF7lFyJgY6g.png" /></figure><ol><li><strong>Initiation<br>AI impact:</strong> Low<br><strong>What AI can do:</strong> Generate drafts, project briefs, and initial scoping documents. <br><strong>What still needs humans:</strong> Business case judgment, stakeholder alignment, and funding decisions</li><li><strong>Requirements<br>AI impact:</strong> Medium<br><strong>What AI can do:</strong> Explore possibilities, generate spec drafts, and identify gaps in coverage<br><strong>What still needs humans:</strong> Validation, prioritisation, constraint negotiation, and regulatory fit</li><li><strong>Design<br>AI impact:</strong> Medium-High<br><strong>What AI can do:</strong> Generate UI mockups, architecture drafts, and data models<br><strong>What still needs humans:</strong> Architectural trade-offs, system boundary decisions, and security posture</li><li><strong>Development<br>AI impact:</strong> High<br><strong>What AI can do:</strong> Code generation, rapid prototyping, boilerplate elimination<br><strong>What still needs humans:</strong> Architecture ownership, security integration, and code review discipline</li><li><strong>Testing<br>AI impact:</strong> Medium<br><strong>What AI can do:</strong> Generate test cases, surface patterns, and automate regression<br><strong>What still needs humans:</strong> Test strategy, edge case reasoning, acceptance criteria definition</li><li><strong>Deployment<br>AI impact:</strong> Low<br><strong>What AI can do:</strong> Assist with scripts, configuration, and environment setup<br><strong>What still needs humans:</strong> Infrastructure decisions, rollback planning, and release coordination</li><li><strong>Monitoring<br>AI impact:</strong> Low<br><strong>What AI can do:</strong> Help set up dashboards, generate alert templates<br><strong>What still needs humans:</strong> Alert logic, incident response ownership, operational accountability</li><li><strong>Closure<br>AI impact:</strong> None<br><strong>What AI can do:</strong> Minimal value<br><strong>What still needs humans:</strong> Lessons learned, stakeholder sign-off, knowledge transfer</li></ol><p>The pattern is clear: AI compresses the middle of the lifecycle, where artefact generation dominates, while the phases that depend on organisational judgment, accountability, and real-world feedback remain human responsibilities. This is the baseline against which every AI prototyping claim should be measured.</p><h4>Thesis 2: AI prototyping mainly changes when teams learn, not just how fast they generate artefacts</h4><p>Traditional project and product frameworks, including PMBOK [1], PRINCE2 [4], and Stage-Gate [10], all assume that work moves through stages of definition, delivery, control, and handoff. Their terminology differs, but the basic idea is the same: decisions should be tied to evidence, ownership, and a clear path forward.</p><p>AI prototyping changes this lifecycle primarily by lowering the cost of tangible exploration. <strong>Once a team can produce a visible artefact quickly, learning and alignment can happen earlier, before requirements and expectations harden.</strong> That is why the strongest upside is not interface speed by itself. It is an earlier shared understanding.</p><h4>Thesis 3: Prototype, MVP, and V1 are different categories of progress</h4><p>Lean Startup [6] is useful here because it frames the MVP around validated learning rather than around demo value. SVPG [5] sharpens the distinction further by separating discovery artefacts from production-oriented work. Together, these frameworks support a simpler breakdown:</p><ul><li>A prototype explains, explores, or tests an idea</li><li>An MVP accepts real-world exposure to learn under actual constraints</li><li>A V1 carries a stronger production commitment to reliability, maintainability, and support</li></ul><p><strong>In practice, progress on prototypes should not be counted as MVP progress</strong>. A team may learn a great deal from a prototype, but that learning does not mean the artifact is technically, operationally, or economically ready to become a product.</p><h4>Thesis 4: AI-generated prototypes create understanding risk as well as speed benefits</h4><p>NN/g [2] is especially useful because it documents a familiar pattern: AI prototyping tools can produce outputs that look convincing while remaining weak in actual design contexts. AI systems are good at producing plausible forms quickly, but plausible is not the same as reliable.</p><p>This creates a serious understanding risk. Teams may mistake visual coherence for problem validation — treating a convincing screen as evidence that the underlying problem is real, the solution is workable, or the system is production-ready — when in fact only the artefact is convincing. That is one of the strongest versions of what people loosely call <strong>AI slop.</strong></p><p>The danger is not only ugly or low-quality output. The danger is output that is misleading, unvalidated, or careless, yet still persuasive enough to move decisions forward.</p><p>Design polish should be treated as a reason to review more carefully, not as a reason to lower the bar.</p><h4>Thesis 5: The transition from prototype to product is where the real cost appears</h4><p>Google SRE [11] is useful because it makes hidden toil visible. Martin Fowler [7] is useful because sacrificial architecture normalises the idea that rewriting can be rational when early code was optimised for learning rather than durability. Stage-Gate [10] is useful because it frames progression as something that must earn more commitment through evidence.</p><p>Taken together, these sources support a simple economic point. The cheap part of AI prototyping is generation. <strong>The expensive part is everything that follows if the organisation decides the artefact now matters: integration, security, test coverage, supportability, monitoring, data handling, ownership, and operational maintenance.</strong></p><p>This is why the prototype-to-product transition is often the most important strategic decision in the whole workflow. The question is no longer whether the demo impressed people. The question is whether the organisation should discard it, rewrite it, or deliberately evolve it.</p><h4>Thesis 6: Governance, security, and data trust remain load-bearing even when artefact creation becomes cheap</h4><p>According to Bolt PMO practices, delivery discipline still depends on explicit ownership, risk visibility, communication, and clear closure. Public frameworks reach a similar conclusion through different languages. PRINCE2 [4] emphasises staged control and accountability. NIST [8] adds governance and risk framing for AI-heavy contexts. FTC [12] serves as a reminder that <strong>misleading representations can create trust and claims risk even when the underlying technology is still exploratory</strong>.</p><p>The same logic extends into security and data handling. Sandboxing is useful, but it is often misunderstood. An isolated environment can reduce exposure and limit the damage caused by mistakes, making it valuable for experiments. What it does not do is magically turn a prototype into something production-safe. Access, logging, observability, patching, tool permissions, and incident response still need to be deliberately designed. Public security guidance, such as NIST [8] and OWASP [9], is helpful here because it shows that safety is a lifecycle concern, not just a demo concern.</p><p><strong>Using real or production-like data in a prototype often creates more risk than learning value</strong>. The moment a prototype uses real data, it inherits privacy, contractual, trust, and quality obligations that may exceed the value of the experiment. On top of that, generative systems can produce plausible outputs that appear trustworthy long before they are actually reliable. That is why exploratory work should default to synthetic, minimised, or clearly bounded data wherever possible.</p><p>An AI prototype should not be moved into production “as is” simply because it appears functional. Most such artefacts are optimised for speed, presentation, and demo success. Production systems need a different kind of quality: clear permissions, observability, resilience, support ownership, and safer data assumptions.</p><p>So, faster prototyping should not weaken governance. It should make governance more precise. Sandboxing should be treated as containment, not proof. Real data should raise the bar, not lower it. And productionization should be treated as a separate decision gate, not as an automatic continuation of prototype success.</p><h3>Applied: Product readiness comparison with and without AI</h3><p>Building on the research above, this section compares the product lifecycle with and without AI using an example close to a real production case. The simplified timeline below shows the core tension. AI can move teams to a prototype and even an MVP faster, but the road from MVP to V1 still contains validation, governance, integration, and transition work that no attractive demo can wish away. On the AI-prototyping path, readiness can even drop after the first successful MVP, because the team often has to rebuild, harden, or redesign the prototype before a real V1 becomes supportable.</p><p>The table below compares six realistic development scenarios from idea to V1, with risk called out for each path. Public sources provide useful directional anchors: AI-native MVP providers describe prototype or MVP delivery in days to weeks. In contrast, more conventional MVP delivery often lands in the 8–18 week range before broader production hardening [15][16][17][18]. NN/g adds an important caution: AI prototypes can be useful for early exploration and stakeholder communication, but they still require validation, refinement, and human judgment before anything ships [2].</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*adQJ4iNTQ08jwTUAteLmXA.png" /></figure><p><strong>Reading the comparison</strong></p><p>This table should be read as a lifecycle model, not as a measured benchmark. The prototype and MVP columns show how quickly each path can create a visible artefact. The rewrite and V1 columns show where the hidden cost appears after the demo looks successful.</p><p>The figures are source-informed synthetic estimates, drawn from public references, AI-assisted research, and the author’s own delivery experience. They are not measured benchmarks and do not represent an official Bolt position. Read them as a way to compare lifecycle tradeoffs, rewrite risk, and transition cost — not as a universal delivery forecast. In the author’s view, the model is close to reality, including patterns observed in production work with the Bolt Delivery Catalog team.</p><p><strong>Scenarios</strong>:</p><ul><li><strong>Scenarios 1 and 5: based on the traditional model</strong>, production-shaped delivery.<br>The traditional path and the AI-assisted copilot path differ in speed but are similar in discipline. In both cases, the work stays close to a real product shape: architecture, ownership, security, data handling, and maintainability are considered during the build, not only after the demo. Scenario 5 is often the strongest path because AI accelerates prototyping and MVP work, while human architecture keeps the rewrite tax low.</li><li><strong>Scenarios 2 and 3: AI-prototype-based,</strong> faster discovery, same product burden.<br>AI prototype-only and serial AI prototyping both compress the front of the lifecycle. They help teams make ideas visible earlier and explore more directions before commitment. But they do not automatically shorten the harder path to V1. In scenario 2, the team still faces the same MVP and production work after the handoff. In scenario 3, the risk is different: when every direction can be demoed quickly, the team may keep exploring instead of deciding. The work feels fast, but commitment can be delayed.</li><li><strong>Scenarios 4 and 6: Prototyped MVP</strong>, convincing artefacts with high transition risk.<br>AI-generated prototypes and AI-generated MVPs can create the strongest illusion of progress. Scenario 4 may reach an apparent MVP quickly, but the artefact is often optimised for demo paths and presentations rather than for production durability. Scenario 6 amplifies this risk: full AI generation can produce a convincing MVP-like artefact, but V1 may never arrive because the system cannot withstand production demands such as permissions, observability, resilience, support ownership, and handling real data.</li></ul><p>The core pattern is: <strong>AI can dramatically compress the front of the lifecycle, but V1 remains a production and organisational commitment</strong>. The fastest credible path is not “use as much AI as possible.” It is “use AI where it accelerates learning, and keep human architecture where it preserves production value.”</p><h3>Conclusion</h3><p><strong>So what does all of this mean? How should teams actually use AI?</strong></p><p>There is no single “correct” answer yet. Practice is still catching up with the speed of the tools. But one thing is already clear: AI is not valuable just because it can generate something quickly. It is valuable when it helps people understand, decide, and act better.</p><p>Many teams first met AI as a text tool: summarise this, rewrite that, draft a document, prepare a plan. That was useful, but it still mostly lived in the world of words. AI prototyping moves the same question into a more powerful and more dangerous space: now AI does not only describe an idea — it can make the idea look real. And with great power comes greater responsibility.</p><p>The main risk is not AI replacing people; it is <strong>teams failing to understand what the AI helped them create.</strong> When that happens, AI stops being an accelerator and becomes a source of noise, hype, and misleading confidence. AI prototyping is one practical example of this broader pattern. Avoiding that requires a clear problem statement from the beginning. It works best when it is used to answer concrete questions: Is this direction worth exploring? Can we compare options before committing? Do stakeholders align? Is it ready to be shown to customers? In those cases, a prototype creates value by accelerating learning.</p><p>Put simply, AI prototyping lowers the cost of learning. It does not eliminate the cost of commitment. <strong>A successful prototype is not the end of the lifecycle. It is the beginning of a new decision.</strong></p><p><strong>In conclusion,</strong> I want to shortlist the key takeaways (the same practices described earlier): they help maintain discipline throughout AI prototyping.</p><p><em>1. Start with the problem, not the prototype.</em></p><p><em>2. Use prototypes to explore, not to anchor too early.</em></p><p><em>3. Assign one owner end-to-end.</em></p><p><em>4. Keep the prototype connected to a decision record.</em></p><p><em>5. Label the artefact honestly and keep lifecycle boundaries clear.</em></p><p><em>6. Use safe demo conditions (no real data by default, limited permissions).</em></p><p><em>7. Review before broad exposure.</em></p><p><em>8. Decide the transition path early: discard, rewrite, or evolve.</em></p><p><em>9. Price the real cost and timebox the effort.</em></p><h4><strong>Join Bolt</strong></h4><p>Grow fast, make a global impact, and help make cities for people, not cars. Explore open roles on our <a href="https://bolt.eu/en/careers/positions/?teams%5B0%5D=Engineering">career page</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*QxxNitEiRpICJSzJ.jpg" /></figure><h3>Links</h3><ol><li>Project Management Institute. (2021). <em>A guide to the Project Management Body of Knowledge (PMBOK guide) and the standard for project management</em> (7th ed.).<a href="https://www.pmi.org/standards/pmbok"> https://www.pmi.org/standards/pmbok</a></li><li>Brown, M. (n.d.). Good from afar, but far from good: AI prototyping in real design contexts. <em>Nielsen Norman Group</em>.<a href="https://www.nngroup.com/articles/ai-prototyping/"> https://www.nngroup.com/articles/ai-prototyping/</a></li><li>Agrawal, A., &amp; Sharma, A. (2026, April 15). AI prototyping is changing how we build products at Uber. <em>Uber Blog</em>.<a href="https://www.uber.com/us/en/blog/ai-prototyping/"> https://www.uber.com/us/en/blog/ai-prototyping/</a></li><li>PRINCE2. (n.d.). <em>PRINCE2 project management processes</em>.<a href="https://www.prince2.com/uk/prince2-processes"> https://www.prince2.com/uk/prince2-processes</a></li><li>Cagan, M. (n.d.). Prototypes vs products. <em>Silicon Valley Product Group</em>.<a href="https://www.svpg.com/prototypes-vs-products/"> https://www.svpg.com/prototypes-vs-products/</a></li><li>Ries, E. (2009, August 3). What is an MVP? <em>Lean Startup Co.</em><a href="https://leanstartup.co/what-is-an-mvp/"> https://leanstartup.co/what-is-an-mvp/</a></li><li>Fowler, M. (2014, July 1). Sacrificial architecture. <em>martinfowler.com</em>.<a href="https://martinfowler.com/bliki/SacrificialArchitecture.html"> https://martinfowler.com/bliki/SacrificialArchitecture.html</a></li><li>Autio, C., Schwartz, R., Dunietz, J., Jain, S., Stanley, M., Tabassi, E., Hall, P., &amp; Roberts, K. (2024). <em>Artificial intelligence risk management framework: Generative artificial intelligence profile</em> (NIST AI 600–1). National Institute of Standards and Technology.<a href="https://doi.org/10.6028/NIST.AI.600-1"> https://doi.org/10.6028/NIST.AI.600-1</a></li><li>OWASP Foundation. (2025). <em>OWASP GenAI Security Project</em>.<a href="https://genai.owasp.org/"> https://genai.owasp.org/</a></li><li>Stage-Gate International. (n.d.). The Stage-Gate model: An overview.<a href="https://www.stage-gate.com/blog/the-stage-gate-model-an-overview/"> https://www.stage-gate.com/blog/the-stage-gate-model-an-overview/</a></li><li>Beyer, B., Murphy, N. R., Rensin, D. K., Kawahara, K., &amp; Thorne, S. (Eds.). (2018). Eliminating toil. In <em>The site reliability workbook</em>. O’Reilly Media.<a href="https://sre.google/workbook/eliminating-toil"> https://sre.google/workbook/eliminating-toil</a></li><li>Atleson, M. (2023, February 27). Keep your AI claims in check. <em>Federal Trade Commission Business Blog</em>.<a href="https://www.ftc.gov/business-guidance/blog/2023/02/keep-your-ai-claims-check"> https://www.ftc.gov/business-guidance/blog/2023/02/keep-your-ai-claims-check</a></li><li>International Organization for Standardization. (2020). <em>Project, programme and portfolio management — Guidance on project management</em> (ISO 21502:2020).<a href="https://www.iso.org/standard/74947.html"> https://www.iso.org/standard/74947.html</a></li><li>Gray, A., Richardson, K., Rooke, K., &amp; Thornburn, T. (2017). <em>Guide to life cycles and life cycle models</em> (Issue 1.1). INCOSE UK &amp; Association for Project Management.<a href="https://www.apm.org.uk/media/sg0mg1d1/guide-to-lifecycle-models.pdf"> https://www.apm.org.uk/media/sg0mg1d1/guide-to-lifecycle-models.pdf</a></li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=27a8a4d1dcbd" width="1" height="1" alt=""><hr><p><a href="https://medium.com/bolt-labs/ai-prototyping-reality-check-27a8a4d1dcbd">AI-Prototyping: Reality Check</a> was originally published in <a href="https://medium.com/bolt-labs">Bolt Labs</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AAAAA Testing: How to make tests AI-friendly]]></title>
            <link>https://medium.com/bolt-labs/aaaaa-testing-96583245ae24?source=rss-fe6591673721------2</link>
            <guid isPermaLink="false">https://medium.com/p/96583245ae24</guid>
            <category><![CDATA[testing]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[clean-code]]></category>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Fedor Novikov]]></dc:creator>
            <pubDate>Wed, 04 Feb 2026 12:17:33 GMT</pubDate>
            <atom:updated>2026-02-16T18:52:33.554Z</atom:updated>
            <content:encoded><![CDATA[<h4>Written by <a href="https://medium.com/u/fe6591673721">Fedor Novikov</a> and <a href="https://medium.com/u/912187747919">Alexander Aronov</a>, <br>Engineering Managers at Bolt.</h4><h3>Introduction</h3><p>For anyone who develops software, writes code, and eventually writes tests (unit, integration, or component), this article is for you. It doesn’t matter if you’re working on a microservice, a monolith, a frontend app, a mobile client, or a shared library. We’ve all been there: tests that are so complicated they’re harder to read, write, and refactor than the production code they’re meant to validate. <strong>If your test suite feels like it’s fighting you, you’ve come to the right place.</strong><br>You should care because this isn’t about test theory, but about readable, explicit tests that reduce the cost of change, make failures easier to diagnose, and let you evolve your code without fighting your suite. And if you want <strong>AI to help</strong> you write, review, and refactor tests, your tests need a structure that’s easy to understand and validate.<br>Often, the reason is the complexity introduced by tangled mocking and setup utilities, as well as the massive amounts of imperative logic (if statements) required to manage test state. <strong>We believe logic should be in your application, not in your tests.<br></strong>To address this, we refined the classic Arrange-Act-Assert pattern into a more robust approach: <strong>AAAAA Testing</strong> (pronounced “Penta A”), which stands for Arrange, Anticipate, Act, Assert, and AI.</p><p>If you’re familiar with the AAA (GWT) testing theory, you can skip this section and move on to the next part — <strong>The problem with ‘if’ statements</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1JfOJiO0kybLVMCSRfMjmg.jpeg" /></figure><h3>AAA testing approach</h3><p>The Arrange-Act-Assert (AAA) pattern is a widely adopted and excellent starting point for test structure. The AAA pattern is described and recommended by well-known figures and organisations in software engineering, including Martin Fowler and Bill Wake.</p><p>It dictates 3 simple phases:<br><strong>Arrange</strong>: Prepare the initial state, data, and preconditions for the test. This often involves initialising database data or creating test fixtures.<br><strong>Act</strong>: Perform the single action under test. This is typically calling a function or hitting an API endpoint.<br><strong>Assert</strong>: Verify the outcome, checking the return value, database state, and any side effects.</p><p><strong>A quick detour: AAA vs. Given-When-Then (GWT)</strong><br>A common point of confusion is whether AAA is the same as Given-When-Then (GWT).<br>They represent fundamentally different approaches to test design. Although AAA and GWT both follow the same 3-phase structure (prepare, perform, verify), they emphasise different communicative goals. Given-When-Then originated in Behaviour-Driven Development (BDD) — to make tests readable to non-technical stakeholders. A single GWT scenario often encodes an entire user workflow and may embed conditional logic in​​ step definitions. <br>The AAA pattern, by contrast, enforces atomicity: one action per test, explicit state in Arrange, direct checks in Assert, with no branching. This structural discipline makes AAA tests more <em>declarative</em> — they state <em>what holds</em> at each phase rather than <em>how</em> to verify complex scenarios, resulting in higher readability and lower maintenance burden compared to GWT’s implicit step logic.</p><p><strong>GWT:<br>Abstracts the details:</strong> Focuses on the “happy path” and business logic while hiding the technical implementation.<br><strong>Broad scope:</strong> Encourages covering full scenarios, though this can sometimes lead to trying to test everything in a single go.<br><strong>Complex flow: </strong>Often relies on imperative steps that include conditional logic (“if” statements) to handle complex behaviours.</p><pre>ctest(&quot;v1ProductSearch should return list of products with images&quot;, async (ctx: Context) =&gt; {<br>  // Given<br>  await ProductUtils.arrangeProducts(<br>    ctx,<br>    boot,<br>    [PRODUCT1, PRODUCT2],<br>    false,<br>    true, // has_image=true resulted in an if statement in the utils<br>    true // search images external call <br>  );<br><br>  // When<br>  const response = await boot.input.internalApi.v1ProductSearch(ctx, {<br>    region_id: REGION_ID_ROMANIA,<br>  });<br><br>  // Then<br>  ProductUtils.assertProductSearchResponse(<br>    response,<br>    [PRODUCT1, PRODUCT2],<br>    {<br>      has_images: true     <br>    }<br>  );<br>});</pre><p><strong>AAA:<br>Details matter:</strong> clearly define the atomic steps before taking action.<br><strong>Focused scope: </strong>Discourages comprehensive tests, favouring small, isolated checks instead.<br><strong>Linear flow: </strong>Keeps the test declarative and straightforward, usually avoiding the need for complex conditional logic.</p><pre>ctest(&quot;v1ProductSearch should return list of products with images&quot;, async (ctx) =&gt; {<br>  // Arrange<br>  await insertProductWithImage(boot, ctx, PRODUCT1.sku, IMAGE.id);<br>  await insertProductWithImage(boot, ctx, PRODUCT2.sku, IMAGE.id);<br><br>  this.boot.output.imageStoreInternalApi.v1ImageSearch.once({<br>    body: {<br>      id: IMAGE.id<br>    }},<br>    Response.data({<br>      id: IMAGE.id,<br>      url: IMAGE.url,<br>      image_type: &#39;jpg&#39;<br>    })<br>  );<br><br>  // Act<br>  const response = await boot.input.internalApi.v1ProductSearch(ctx, {<br>    region_id: REGION_ID_ROMANIA<br>  });<br><br>  // Assert<br>  response.expectOk();<br>  const { products } = response.getData();<br>  expect(products).toIncludeSameMembers([<br>    object.expectContaining({sku: PRODUCT1.sku, image: {url: IMAGE.url}}),<br>    object.expectContaining({sku: PRODUCT2.sku, image: {url: IMAGE.url}})<br> ]);<br>});</pre><p>Probably now you’re wondering how the AAA code can be better than the GWT one. It has more lines, and now we need to know how to insert products, mock the image search call, and so on.<br>But there’s an elephant in the room: ProductUtils from the example above conceals a lot of code inside. You might not care about it at first, but when you need to add one more property, you look inside, and what do you see?</p><pre>async function arrangeProducts(boot, ctx, products, arrangeCategories=true, arrangeImages=true, mockImageSearch = true) {<br>  for (const product in products) {<br>    if (arrangeCategories &amp;&amp; !arrangeImages) {<br>      const category = CategoryUtils.insertCategory(CATEGORY); <br>      await insertProductWithCategory(boot, ctx, product, category);<br>    }<br>    else if (arrangeCategories &amp;&amp; arrangeImages) {<br>      await insertProductWithCategoryAndImages(boot, ctx, product, IMAGE, CATEGORY);<br>    }<br>    else if (arrangeImages) {<br>      await insertProductWithImage(boot, ctx, product, IMAGE.id);<br>    }<br>    else {<br>     await insertProduct(boot, ctx, product);<br>    }<br><br>    if (mockImageSearch) {<br>      ImageUtils.mockImageSearch(IMAGE);<br>    }<br>}</pre><h3>The problem with ‘if’ statements: When logic starts to smell</h3><p>The utils use other utils based on conditional logic, and you can see how this becomes increasingly complicated and tightly coupled to each entity and operation they have to support.<br><strong>That’s “mocking hell”: tests that are hard to read, hard to refactor, tightly coupled with, and sometimes more complex than the code they’re supposed to protect.<br></strong>The setup phase turns into a forest of conditions:</p><ul><li>If the payload contains X, return Y.</li><li>If the flag is false, throw an error.</li><li>If the retry count is N, simulate a timeout.</li></ul><p>What used to be “Arrange” becomes a miniature implementation of business logic, and the test ends up tightly coupled to both the implementation and the mock wiring. It creeps into verifying internal and intermediate steps, leading to tight coupling between the implementation and the mock wiring.</p><h3>But even with AAA, doesn’t something still feel wrong?</h3><p>When we write tests for real systems, mocking external dependencies is often the most painful part. These dependencies can include third-party functions, API calls, message publishing, or reading from storage — we usually just want to “mock them out” to keep tests deterministic.<br>Over time, however, the test takes on a second role. It not only sets up data and verifies the outcome, but also has to predict and control every external interaction along the way. In practice, this means defining and validating what the system will send and what it should receive in return.</p><p>A good way to break this cycle is to stop treating external mocking as a side detail and make it an explicit phase of the test. In our approach, we separate external interactions into a dedicated step called <strong>Anticipate</strong>. We propose moving the coupling points into a separate function, which allows the rest of the test to remain clean.</p><h3>Anticipate</h3><p>We found that extracting third-party calls into separate functions makes mocking lightweight and far less coupled, since these calls are the primary points of coupling. Anticipate is the place where the test describes, in a declarative way, what the component is expected to do when it tries to communicate with something outside its boundary.</p><p>It’s the moment when we say: “When the component calls this endpoint, with this payload, respond like this.” The important part is that <strong>Anticipate</strong> is not only about returning predefined responses — it also verifies the interaction: it ensures the expected call was actually made, and that it was made with the correct inputs derived from the arrangement. It includes both the <strong>Arrange</strong> and <strong>Assert</strong> aspects of mocking.</p><p>That small structural change gives us a clearer lifecycle:</p><ol><li><strong>Arrange</strong> creates the data and preconditions;</li><li><strong>Anticipate</strong> defines and validates all external interactions;</li><li><strong>Act</strong> executes the component;</li><li><strong>Assert</strong> checks the result.</li></ol><p>So the flow becomes:<strong> Arrange → Anticipate → Act → Assert</strong>.</p><p>At this point, you might ask: Doesn’t this just move complexity from one place to another? It could, if we allowed Anticipate to turn into a smart, branching monster. The trap is the same as before: it’s tempting to write anticipation rules like “if this field is true, return success, otherwise return an error.” That kind of logic makes Anticipate behave like a decision engine, and soon you’re back to tests that are difficult to reason about.<br>The discipline we use is simple: <strong>anticipation should be atomic</strong>. It should represent one specific expected interaction and one specific response, <strong>without internal branching</strong>. If you need different outcomes, you don’t implement them as if statements inside a single anticipation. You create individual anticipation scenarios for individual functions.</p><p>Yes, this can introduce code duplication. But in this case, duplication isn’t a smell — it’s a boundary. Each scenario becomes an explicit, readable building block: the success path, the “missing field” error, the “unauthorised” response, the timeout, and so on. These blocks are easier to compose, easier to refactor, and harder to couple together accidentally.</p><p>In a TypeScript testing context, an Anticipation function looks like this:</p><pre>ctest(&quot;v1ProductSearch should return list of products with images&quot;, async (ctx) =&gt; {<br>  // Arrange<br>  await insertProductWithImage(boot, ctx, PRODUCT1.sku, IMAGE_ID);<br>  await insertProductWithImage(boot, ctx, PRODUCT2.sku, IMAGE_ID);<br><br>  // Anticipate<br>  const image = anticipateImageSearch(IMAGE_ID);<br>    <br>  // Act<br>  const response = await boot.input.internalApi.v1ProductSearch(ctx, {<br>    region_id: REGION_ID_ROMANIA,<br>  });<br><br>  // Assert<br>  response.expectOk();<br>  const { products } = response.getData();<br><br>  expect(products).toHaveLength(2);<br>  expect(products.every((p) =&gt; p.image?.url === image.url)).toBeTruthy();<br>});<br><br>// Anticipation functions:<br>public anticipateImageSearch(image_id: number = IMAGE_ID) {<br>  const image = {...IMAGE, id: image_id};<br>  this.boot.output.imageStoreInternalApi.v1ImageSearch.once({<br>    body: {<br>      id: image_id<br>    }},<br>    Response.data({<br>      id: image_id,<br>      url: image.url,<br>      image_type: &#39;jpg&#39;<br>    })<br>  );<br>  return image;<br>}<br>public anticipateImageSearchFailed(image_id: number = IMAGE_ID) {<br>  this.boot.output.imageStoreInternalApi.v1ImageSearch.once({<br>    body: {<br>      id: image_id<br>    }},<br>    Response.code(ResponseCodes.CLIENT_TIMEOUT)<br>  );<br>}</pre><p>Notice how the logic is contained in a single, reusable function that’s defined before the test case. Then we can make as many functions as needed for other scenarios.</p><p>This approach allows tests to remain:</p><ul><li>Atomic: Tests one thing.</li><li>Declarative: The scenario is defined upfront.</li><li>Reusable: Anticipations can be used in every test that interacts with that client.</li></ul><h3>Generators</h3><p>No “if” statements and code copy-pasting — both lead to too many lines, which quickly become hard to read for humans, but AI handles it well. To improve readability, we propose wrapping object initialisation into generator functions that define all default parameters.<br>This means you don’t need to specify every field of an object and can focus only on what is essential for the test. With this approach, objects and mocks can be generated directly in the test without adding excessive code.<br>This makes the code less disruptive and less bulky. For example:</p><pre>const imageGenerator = (image: Partial&lt;Image&gt;): Image =&gt; {<br>  return {<br>    id: image.id ?? number.iterate(),<br>    url: image.url ?? string.iterate(&#39;http://bolt.eu/image/&#39;),<br>    image_type: image.image_type ?? enum.iterate(&quot;png&quot;, &quot;jpg&quot;)<br>  }<br>}<br>const image = imageGenerator({url: &quot;invalid url&quot;})</pre><p>We went further and built the entire generator framework, focusing on making object creation easy, immutable, and predictable, with consistent and repeatable results.</p><h3>The full framework: AAAAA (the fifth A)</h3><p>The final ‘A’ stands for AI. We discovered that by strictly enforcing the 4-stage structure (Arrange, Anticipate, Act, Assert), we inadvertently created a testing style that’s surprisingly friendly to AI-powered code generation tools.</p><p>The structured, declarative nature of AAAA means the test context is clear, explicit, and segmented. This predictable structure allows tools to generate entire, high-quality tests or complex mock/anticipation stories with minimal hallucination or error. <br>To ensure maximum AI compatibility and minimal ‘mocking hell’ recurrence, we enforce a strict set of rules, which are essentially best practices for clean testing.</p><p>An example of rules:</p><pre>Structure: Each test must follow the Arrange → Anticipate → Act → Assert. <br>A test validates exactly one action. What state to set up (Arrange)?<br>What external interactions to simulate (Anticipate)? <br>What function to call (Act)? <br>What results to check (Assert)?<br>No Logic: Tests must contain no branching or inline logic (if statements, for loops). <br>The fixtures and anticipations fully define the scenario.</pre><p>We wrote down all our assumptions about how tests should follow AAAA. Then, we described what is good and what is bad, giving examples to help AI. After that, it’s ready and works great in the production code.</p><h3>Why does this work well with AI?</h3><p>The AAAA approach encourages a very declarative style: it minimises external dependencies and wraps functions and classes, making tests more self-contained. On one hand, you still need to understand each test, but that understanding requires much less effort because the test carries its own <strong>context</strong>.<br>This significantly reduces the amount of context an AI model needs to keep in mind. Each test effectively encapsulates its own setup and assumptions. Of course, the program code still needs to be in context, but that’s unavoidable.<br>As a result, AI tools are less likely to “guess” missing details and can generate or extend tests with fewer hallucinations. With the right manual, AI can easily write, read, and validate tests, and repetitive changes that may now arise can be handled easily.</p><h3>Join Bolt</h3><p>Grow fast, make a global impact, and help make cities for people, not cars. Explore hundreds of open roles <a href="https://bolt.eu/en/careers/positions/?teams%5B0%5D=Engineering">on our careers page.</a></p><h3>References</h3><p>1 <a href="https://martinfowler.com/bliki/GivenWhenThen.html">https://martinfowler.com/bliki/GivenWhenThen.html</a><br>2 <a href="https://xp123.com/3a-arrange-act-assert/">https://xp123.com/3a-arrange-act-assert/</a><br>3 <a href="https://betterprogramming.pub/rethinking-testing-through-declarative-programming-335897703bdd">https://betterprogramming.pub/rethinking-testing-through-declarative-programming-335897703bdd</a><br>4 <a href="https://semaphore.io/blog/aaa-pattern-test-automation">https://semaphore.io/blog/aaa-pattern-test-automation</a><br>5 <a href="https://www.google.com/url?q=https://dev.to/leeannamarshall225/bdd-automated-testing-vs-unit-testing-key-differences-explained-43i3&amp;sa=D&amp;source=docs&amp;ust=1770116222616161&amp;usg=AOvVaw1IuyP1w8NPyEO7HBeblmQD">https://dev.to/leeannamarshall225/bdd-automated-testing-vs-unit-testing-key-differences-explained-43i3</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=96583245ae24" width="1" height="1" alt=""><hr><p><a href="https://medium.com/bolt-labs/aaaaa-testing-96583245ae24">AAAAA Testing: How to make tests AI-friendly</a> was originally published in <a href="https://medium.com/bolt-labs">Bolt Labs</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>