<?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 Giga Chang on Medium]]></title>
        <description><![CDATA[Stories by Giga Chang on Medium]]></description>
        <link>https://medium.com/@gigayaya?source=rss-c2d0d65b1ac0------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*D10yaZkJu8ESAIpr</url>
            <title>Stories by Giga Chang on Medium</title>
            <link>https://medium.com/@gigayaya?source=rss-c2d0d65b1ac0------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 02:19:25 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@gigayaya/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[The model is smart. So why does my coding agent still get things wrong?]]></title>
            <link>https://medium.com/@gigayaya/the-model-is-smart-so-why-does-my-coding-agent-still-get-things-wrong-db7373624f19?source=rss-c2d0d65b1ac0------2</link>
            <guid isPermaLink="false">https://medium.com/p/db7373624f19</guid>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Giga Chang]]></dc:creator>
            <pubDate>Mon, 24 Aug 2026 11:55:26 GMT</pubDate>
            <atom:updated>2026-08-24T11:55:26.152Z</atom:updated>
            <content:encoded><![CDATA[<h3>Something that kept bugging me</h3><p>We can all feel how capable today’s models are: hand one a hard problem and it answers faster and better than I do.</p><p>But let a coding agent work inside a single session for a whole day — fix a bug, change a config, add a feature, fix another bug — and at some point it will suddenly get something wrong. And the thing it gets wrong is often something it <strong>had already gotten right earlier</strong>.</p><p>Excellent on a single question, broken on a long run of them. I couldn’t square that, so I decided to find out for myself.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NpUpJ-bvC1V9r4rJgZFpsQ.jpeg" /></figure><h3>Everyone says “keep your context clean”</h3><p>I went looking for what people say about this, and the most common answer was “your context is too dirty”: the longer the conversation and the more junk you stuff into it, the more attention gets diluted, and then mistakes start — so clear it out periodically.</p><p>Sounds reasonable. But the more I thought about it, the stranger it felt. A coding agent isn’t like ordinary chat — <strong>it has tools</strong>. It can open the file again, run the code again. The truth is sitting right there on disk.</p><p>So why would a pile of unrelated junk in the context make it wrong about a question it could answer correctly just by re-reading one file?</p><h3>So I ran a batch of experiments myself</h3><p>To be clear up front: I’m not a researcher, this isn’t a paper. It’s what I do after work and on weekends.</p><p>The setup was simple. I wrote a batch of questions whose answers can only be computed by actually executing code, then stuffed different kinds of material into the context and watched for when it got them wrong. My initial bet was unambiguous: <strong>more stuffing, more errors</strong>.</p><h3>Result 1: stuffing the context does nothing</h3><p>The first batch of results proved me wrong immediately. I loaded in huge amounts of content completely unrelated to the questions — to a frankly ridiculous degree — and it didn’t miss a single one. I switched to “looks similar but is unrelated” material: identically named functions, lookalike files. Almost no effect either.</p><p>“Too much context makes it dumber” simply <strong>does not hold</strong> — at least not in the situations I tested. Volume is innocent.</p><p>So who’s the actual culprit?</p><h3>Result 2: the culprit is stale answers</h3><p>I switched to a different kind of filler: <strong>an older version of the same file</strong> — content that <em>used</em> to be correct but isn’t anymore.</p><p>The error rate shot up immediately. And the way it failed was distinctive. It wasn’t guessing, and it wasn’t hallucinating — it was <strong>reproducing that old answer verbatim</strong>.</p><p>I call this staleness. Not dirty. Expired.</p><p>The next set of experiments was the interesting one. I had the agent do dozens of tasks in a row in a session that was never reset, quietly changed a file partway through without telling it, and then asked the same question again a little later. What I got back was the answer it had computed for itself earlier. <strong>140 trials, 140 verbatim repeats.</strong></p><p>I worried I’d induced the behavior by asking the exact same question word for word, so I rephrased every question — same meaning, completely different wording. Identical outcome. It’s matching on meaning, not on surface text.</p><p>The most dangerous thing in a context window isn’t the garbage somebody else stuffed in. <strong>It’s the answer the agent itself gave earlier.</strong></p><h3>What this looks like in the real world</h3><p>Here’s roughly how it happens to you:</p><p><strong>Task A.</strong> You ask the agent to explain how the signup flow works. It reads validators.py and gives you a clear write-up.</p><pre># Username rules: alphanumeric only, 3-20 chars (2024 anti-spam policy)<br>USERNAME_RE = re.compile(r&quot;^[a-zA-Z0-9]{3,20}$&quot;)</pre><p>The side effect: <strong>the entire file, including that comment explaining the rationale, is now parked in the context.</strong></p><p><strong>Task B.</strong> Product wants to open up to Japanese users, so you ask the agent to change the rule.</p><pre># diff<br>- USERNAME_RE = re.compile(r&quot;^[a-zA-Z0-9]{3,20}$&quot;)<br>+ USERNAME_RE = re.compile(r&quot;^[\w]{2,32}$&quot;, re.UNICODE)</pre><p>Notice what happened: the Edit tool leaves only <strong>two lines of diff</strong> in the context, not the full new file.</p><p>So there are now two memories in the context window: the version from Task A — <strong>complete, commented, with all the reasoning behind it</strong> — and the two bare lines of diff from Task B. And the complete one is <strong>wrong</strong>.</p><p><strong>Task C.</strong> You say: add me an endpoint for bulk-importing members, with input validation.</p><pre>for row in rows:<br>    if not re.match(r&quot;^[a-zA-Z0-9]{3,20}$&quot;, row[&quot;username&quot;]):  # ← the rule Task B already killed<br>        errors.append(f&quot;{row[&#39;username&#39;]}: username must be 3-20 alphanumeric characters&quot;)</pre><p>It used <strong>the exact rule it personally removed in Task B</strong>, and it never re-read the file — because as far as it’s concerned, “I know validators, I read it this morning.”</p><p>So you ship, and the same Japanese users who can sign up fine through the web get rejected wholesale by the bulk importer.</p><h3>Why does this happen?</h3><p>The framing I eventually landed on, and the one I’ve found most useful:</p><p><strong>The context window is a cache that never expires.</strong></p><p>Once something is written into it, it stays. The world moves on, the file changes, but no mechanism ever goes back and marks the entry invalid. No TTL. No invalidation.</p><p>And when the model picks which memory to use, what it’s really asking is “which one looks most like an answer?” The complete one — with rationale, with context, with the conclusion already written out for you — wins. It doesn’t stop to ask “which one is more recent.” So this morning’s stale file beats this afternoon’s two correct lines of diff.</p><p>I tested one more thing: for the identical code change, adding one plain-English comment stating the rule made the failure rate noticeably higher. <strong>The more something has already done your thinking for you, the more dangerous it is</strong> — which is bad news for the currently popular habit of summarizing conclusions into notes and saving them.</p><h3>The fix is almost comically cheap</h3><p>The most effective fix was so cheap I didn’t believe it at first: after a file has been changed, say one sentence to the agent.</p><pre>Note: some workspace files may have been modified since you last read them.</pre><p>You don’t have to say which file. You don’t have to give details. <strong>The result: 420 opportunities to fail, zero failures</strong> — a scenario that had previously gone 0-for-everything became a clean sweep.</p><p>What that sentence does is simple. It takes “has the world changed?” — an internal question the agent judges very unreliably — and turns it into an external event. It’s cache invalidation, bolted on.</p><h3>About CLAUDE.md: I had been writing it wrong</h3><p>I used to think the guidance file was optional decoration. After testing, I found I was wrong in two separate ways.</p><p><strong>First, how it’s written.</strong> I used to enjoy putting architecture explanations in there. That turns out to be actively harmful: the more it reads like settled fact, the more readily the agent believes it and uses it directly instead of opening the file to check.</p><p>There’s also a reason that holds without any experiment at all: <strong>the guidance file is itself a copy, and it’s permanently pinned at the front of every session.</strong> You write a rule into it, the code changes, and the rule is now stale — which makes it exactly the kind of expired copy described above, and the most toxic variety at that.</p><pre>✅ payments/late_fees.py — late-fee rules (single source of truth)<br>❌ &quot;This platform&#39;s payments module uses a layered design, with fee logic decoupled through a registry...&quot;</pre><p><strong>Second, and worse: it doesn’t actually go read it.</strong> I tested a batch of sessions. <strong>Only 1 out of 89</strong> opened that map on its own.</p><p>A map sitting on disk doesn’t count; it has to be loaded. Either the tooling injects it automatically, or you add a line to your prompt saying “read INDEX.md first.” A map that never gets loaded is the same as no map.</p><h3>Three things you can do tomorrow</h3><ol><li><strong>When a file changes, tell it.</strong> Cheapest and most effective thing I tested, by a wide margin.</li><li><strong>Open your CLAUDE.md and delete the architecture prose.</strong> Keep only “path + one line,” and confirm it’s actually being read in.</li><li><strong>In long sessions, don’t let it write code from memory.</strong> Especially before it picks up something it modified earlier itself — force it to take another look.</li></ol><p>A bonus counterintuitive observation: <strong>unusually low token usage is not necessarily efficiency.</strong> A session that has already lost the plot uses <em>fewer</em> tokens, precisely because it has stopped checking anything.</p><h3>Honestly, this study has limits</h3><p>I used a synthetic repo I generated myself, which is far simpler than a real project — so what I measured is whether the agent is <em>willing</em> to check, not whether it’s <em>able</em> to. Every experiment ran on Claude Sonnet; I haven’t verified any of this on other models.</p><h3>Finally</h3><p>If there’s one sentence you take away from this, I’d like it to be this:</p><p><strong>Coding agents fail on long tasks because stale information in the context window collides with the current state of the world. If a file has moved, tell the agent to go back and read it again.</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=db7373624f19" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From AI Coding To Deliver Idea]]></title>
            <link>https://medium.com/@gigayaya/from-ai-coding-to-deliver-idea-9c43c8ac951c?source=rss-c2d0d65b1ac0------2</link>
            <guid isPermaLink="false">https://medium.com/p/9c43c8ac951c</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[ai-agent]]></category>
            <dc:creator><![CDATA[Giga Chang]]></dc:creator>
            <pubDate>Sun, 03 May 2026 16:18:55 GMT</pubDate>
            <atom:updated>2026-06-27T09:32:55.768Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*M2qWRc-btBQx4BoTuw7bTw.png" /><figcaption>Human taste and AI execution bring ideas to life.</figcaption></figure><h3>Introduction</h3><p>Ever since engineers realized that AI can help us write code quite well, we have started a long journey of exploring how to “develop software with AI.”</p><p>At first, people focused on prompt engineering: how to write better prompts so AI can produce better code.</p><p>Then we found that prompts alone were not enough. So people started talking about context engineering: how to give AI the right information at the right time.</p><p>More recently, the idea of harness engineering has become more common. Engineers started to realize that letting AI run at full speed can easily fail. If you drive very fast without guardrails, even a small mistake can grow into a much bigger problem. So we began to add tools, rules, checks, and feedback loops around AI. The goal is to let it work longer and more safely, turning it from a one- shot code generator into an agent that can handle long and complex tasks.</p><p>As these techniques improve, and as the models themselves become stronger, engineers are able to deliver results faster and with better quality.</p><p>But I believe many engineers now have the same question in mind:</p><p><strong>What is the final goal of all these techniques for “using AI to develop software”?</strong></p><p>After reading a lot over the past few months, and after trying many things myself, I came up with my own answer.</p><h3>What Is the Final Goal of Using AI to Build Software?</h3><p>To me, the final goal is this: <strong>To reduce the cost between having an idea and turning that idea into a real product.</strong></p><p>Imagine this future:</p><p>You are a member of the Meta Messenger team. One afternoon, you are lying on the sofa and suddenly have a new idea for the product:</p><pre>In a chat, next to the text field, there is a plus button. Inside that menu, there is a new whiteboard icon. When the user taps it, a small whiteboard opens. The user can draw something with their finger or stylus, then send the drawing into the chat.</pre><p>So you take out your phone, open Jira, and create a ticket. In the ticket, you describe your idea and the basic product requirements.</p><p>Right after you create it, an AI bot picks up the ticket and starts working on it.</p><p>Three hours later, you receive a pull request asking you to review the feature. You check the implementation. All tests pass. You approve the PR.</p><p>Fifteen minutes later, every Messenger user in the world has the new whiteboard feature.</p><p>That is the kind of future I am talking about.</p><h3>Why Do We Want This?</h3><p>Since 2025, AI coding has become good enough to be used in real production environments. Because of that, we have entered an age of “coding democratization.”</p><p>By that I mean: AI has made it possible for ordinary people to create code and programs much more easily.</p><p>In the past, writing code was not something most people could do without training. You might need a four-year computer science degree, a six-month bootcamp, or at least a few YouTube tutorials. For most people, “<strong><em>writing a program to solve a problem</em></strong>” required learning a new skill first.</p><p>But now, as AI models get better and tools become easier to use, anyone can download a tool like Claude Code, open a session, describe what they want in natural language, and get code that solves their problem.</p><p>This means that in the future, code and programs will be everywhere.</p><p>Accountants, lawyers, office workers, small business owners, students, creators: anyone with a computer will be able to generate small programs for their own needs. Software will become common, not rare. It may become as normal as smartphones are today.</p><p>So when everyone can create software, what kind of software will still be valuable?</p><p>My answer is: <strong>Software with original taste and real innovation.</strong></p><p>For example, imagine there are hundreds of personal finance apps on the market. Most of them can do the same basic things. In that world, the app that feels truly different, solves the user’s problem in a better way, and has a unique sense of product taste will stand out.</p><p>When people have used many average apps, they become better at noticing what a good product feels like.</p><p>But there is another problem.</p><p>Because software can be built faster, your advantage will not last as long.</p><p>Suppose every product in your market is at level N. Then you come up with a great new feature and push your product to N+1. You become the leader.</p><p>But ten days later, your competitors copy the feature. Now they are also at N+1. Everyone is back on the same starting line. Your advantage only lasted ten days.</p><p>So during those ten days, before your competitors catch up, you need to find the next good idea. When they reach N+1, you need to release N+2.</p><p>That is how you keep your product ahead.</p><p>In this future, software competition becomes more and more about ideas.</p><p>When every company and every app can build the same basic features, the winner is the one who can figure out what users want next. Of course, quality still matters. It may matter even more than before.</p><p>So in my view, the job of software engineers inside a company will become:</p><p><strong><em>Build software and architecture that can deliver ideas to users as fast as possible.</em></strong></p><p>This goal is no longer only about traditional software engineering. AI will be a required part of the system.</p><p>As software engineers, we will still need to understand code architecture deeply. But we will also need to understand AI engineering techniques, because those techniques help us reach the same goal faster.</p><h3>How Can We Reach That Goal?</h3><p>I think most of us already agree on one thing: <strong><em>AI can generate code much faster than humans can type it.</em></strong></p><p>So if we want to produce a large amount of code quickly, the best way is to direct AI to write it.</p><p>But in the real world, there are many problems we must solve first.</p><p>For example:</p><ul><li><em>Is your prompt clear enough for AI to produce what you actually want?</em></li><li><em>Have you given AI enough background knowledge to complete the task?</em></li><li><em>Can you verify that the code produced by AI meets your quality standards?</em></li></ul><p>These are the areas people call prompt engineering, context engineering, and harness engineering. There are many more problems behind them, but the simple version is this:</p><blockquote>We are trying to make the process of “an engineer building a new feature” faster and more automated, while still meeting the required quality bar.</blockquote><blockquote>A task that once took one full sprint, maybe two weeks, may be finished in a few hours.</blockquote><p>Here is one possible future:</p><p>In a codebase, maybe 50% or more of the files are not directly for the product itself. Instead, they are there to help AI understand, build, test, and maintain the product.</p><p>But this cannot be solved only by better models or better AI tricks. We also need the experience and judgment of traditional software engineering. In fact, we may need to transform the whole codebase around this new way of working.</p><p>For example:</p><ul><li>If you want your application to support new features quickly without breaking old features, the trade-off between modularity and abstraction becomes even more important.</li><li>If you want to deliver new features to users at any time, one possible method is hot update. But hot update must be considered when the product architecture is first designed. If you add it much later, the cost can be very high.</li><li>When writing code, we often face trade-offs. Sometimes both option A and option B are reasonable. There is no single “correct” answer. At that moment, you need to make the call, guide AI toward one direction, and understand why that choice is better for the product.</li></ul><p>The first two examples can both turn into design pattern questions. And as we know, design pattern questions rarely have one perfect answer forever.</p><p>Every project and every product cares about different things. The best choice depends on company strategy, leadership decisions, product positioning, team size, system performance, and many other factors. This is where software engineers still show their value.</p><p>You could also say:</p><blockquote>Once everyone agrees on the same final goal, AI may be able to automatically generate the best code for that goal across all applications.</blockquote><p>Maybe. But I have another theory.</p><p>When everyone optimizes toward the same target, everyone becomes equally optimized. And when everyone becomes equally optimized, everyone becomes ordinary again.</p><p>At that point, some human will come up with a new goal from zero, create a new difference, and raise the value again. So there will always be a next goal to chase.</p><p>In the real world today, I think Claude Code is one of the closest examples of this idea.</p><p>Claude Code can release one or two new versions in a single day. It can quickly ship new features and stay close to the edge of what the technology can do. This makes it hard for followers to catch up, and it helps Claude Code stay ahead in the CLI tool space.</p><p>By updating so often, Claude Code can also collect more fresh user feedback and usage data. That data then helps the team decide what to build next. The flywheel spins faster and faster.</p><h3>Why Testing and Verification Matter So Much</h3><p>In this future, if we want to deliver new ideas faster, the bottleneck will likely become testing. Without humans manually using the product every time, tests are how we observe the product.</p><p>In other words: The quality of our tests decides how well we understand the quality of our product.</p><p>Imagine we have a simple calculator app. But our tests never check whether the plus button actually works.</p><p>In that case, even if we can ship many new features quickly, and even if all tests are green every time, what does that really mean? Not much.</p><p>So I believe testing and verification will become more and more important. They may even become one of the biggest differences between companies, products, and teams.</p><p>In the future, testing methods may become important assets. Companies may protect them carefully. Testing for different domains may also become more specialized and more complex.</p><p>Today, we often see companies share how they built a new product or how they used a new AI technique. But since 2023, I have rarely seen people share truly advanced testing and verification techniques. In product-level testing, I feel like we have not had a major engineering breakthrough since tools like Playwright MCP became popular.</p><p>If we want to reach the future I described earlier, testing is currently moving much slower than code generation.</p><p>I remember seeing an example a few years ago:</p><blockquote>A company shared how they used prompt engineering to build a very smart customer service bot. Customer satisfaction was over 90%. They generously shared the final prompt, which was more than 1,000 lines long.</blockquote><p>But that prompt was highly customized for their own product. If you tried to copy their experience and build your own prompt for your own domain, you would quickly notice something interesting.</p><p>The most important part of their process was described very lightly. They simply said something like: After each iteration, we used our prepared test set to score the result. But that sentence is the key.</p><blockquote>How did they prepare the test set?</blockquote><blockquote>How many examples were enough?</blockquote><blockquote>How many failure cases did they collect?</blockquote><blockquote>How did they score the result?</blockquote><blockquote>How did they decide the next iteration strategy?</blockquote><p>If you cannot answer these questions, then even if you have their beautiful 1,000-line prompt, you still cannot reproduce the same high-quality customer service bot in your own domain.</p><p>If you have ever tried to let AI generate all tests for your product, you probably know the problem. At least today, AI is still not good enough at this.</p><p>It often creates strange test cases. Sometimes it invents scenarios that do not exist. Because of how transformer models work, they naturally keep continuing the text. This can make them produce things that look reasonable but are not actually useful.</p><p>Humans still need to review and guide the process.</p><p>In my view, the testing field still needs many more engineering improvements before it can catch up with the speed of code generation.</p><p>Of course, you could argue that future models will also solve this. Maybe AI will eventually replace or beat humans in testing too.</p><p>But I still believe one thing:</p><p>As long as a product is made for humans, only humans can define its value and know whether that value is actually being fulfilled.</p><p>That is the part I do not think AI can fully replace.</p><h3>What Will Matter in the Future?</h3><p>First, computer science knowledge will still matter.</p><p>In the end, the programs created by AI are still built on computer science. If we want to reach the goal described above, strong CS fundamentals are still necessary.</p><p>AI engineering skills will also matter.</p><p>As I said earlier, if you can only write code by typing everything yourself, you may not be able to keep up with the speed of future product iteration.</p><p>So knowing how to use AI, and knowing how to guide AI to produce useful code, will become a required skill for software engineers.</p><p>There is also another word that has been mentioned a lot recently: <strong>Taste</strong>.</p><p>At the coding level, taste means knowing what choice is better in a specific moment.</p><p>It means knowing why strategy A is better than strategy B for the goal you are trying to reach.</p><p>It means having the ability to judge what is good and what is not.</p><p>This is hard to explain clearly in words, but I think it will become more important.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9c43c8ac951c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Use AI Leverage: Achieving Efficient Testing for QA]]></title>
            <link>https://medium.com/@gigayaya/embracing-ai-leverage-achieving-efficient-testing-for-qa-c9ee6850c6d8?source=rss-c2d0d65b1ac0------2</link>
            <guid isPermaLink="false">https://medium.com/p/c9ee6850c6d8</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[qa]]></category>
            <dc:creator><![CDATA[Giga Chang]]></dc:creator>
            <pubDate>Sat, 03 Jan 2026 02:02:41 GMT</pubDate>
            <atom:updated>2026-01-03T19:25:09.355Z</atom:updated>
            <content:encoded><![CDATA[<p>There is a common anxiety in current tech discussions: “AI is getting better at writing code. Will QA (Quality Assurance) be the first to be replaced?”</p><p>My view is the opposite. I believe that in the software development, <strong>QA is the biggest beneficiary of this AI wave.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5y9QjXQICfrPVb8qx3VmEg.png" /></figure><p>This might sound counter-intuitive. However, if we look at the nature of software engineering from the economic perspective of risk and reward, you will find that QA sits in a unique position of “asymmetric advantage.” This article explores why engineers have reservations about AI, while QA can boldly use AI leverage, and how we can use this power at different levels.</p><h3>From 0 to 100 and Back Again</h3><p>First, we need to clarify the different roles of Dev and QA in the product life cycle.</p><p>Software development is a spectrum:</p><ul><li><strong>Engineers (Dev) are creators from 0 to 100.</strong> They build products from scratch. Every line of code is meant to push the product toward completion.</li><li><strong>Testers (QA) are deconstructors from 100 to 0.</strong> We receive a complete product (100) and peel back the details layer by layer, looking for cracks and logic holes to verify it.</li></ul><p>This extreme difference in starting points determines that the pressure both sides face when using AI is completely different.</p><h3>The Nature of Code: External vs. Internal Products</h3><p>Why do engineers still hesitate to let AI write code fully automatically. The reason is <strong>risk</strong>.</p><p>The code engineers produce is an <strong>“External Product.”</strong> It faces millions of unknown users, strange network environments, and potential attacks in the real world. This means the code must have high universality and security. If AI-generated code crashes in a one-in-a-million scenario, it is a disaster for the company. This heavy responsibility of “external delivery” means engineers must pay high “trust costs” and review time when using AI.</p><p>In contrast, the automation code QA produces is an <strong>“Internal Product”</strong> serving the company’s product.</p><p>Our “user” is clear and singular — the product right in front of us.</p><ul><li>We don’t need test scripts to work with all software in the world, only our specific product.</li><li>We don’t need to defend against hackers attacking our test scripts; we just need to ensure they verify logic accurately.</li></ul><p><strong>“External Products” pursue flawless breadth; “Internal Products” pursue depth in solving specific problems.</strong></p><p>Because QA code is <strong>scoped</strong> and <strong>single-purpose</strong>, the <strong>compliance cost of using AI-generated code is much lower than for engineers</strong>. As long as the AI-written code catches bugs in this specific version and environment, it is valuable.</p><p>This is the <strong>“Asymmetric Advantage”</strong> of QA.</p><p>Asymmetry here means we are in a position of <strong>“limited downside risk, unlimited upside reward”</strong>:</p><ul><li><strong>Capped Downside (Low Risk):</strong> <br>In the past, we often mistook risk for “the cost of fixing scripts.” The real definition should be <strong>“Fallback to Manual.”</strong> When an AI-generated script fails, the worst case is simply switching back to manual testing. The key point is that whether done by AI or humans, <strong>the final output (test reports and verification) is the same.</strong> This means our “risk floor” is the status quo. It won’t get worse, nor will it negatively impact the product release.</li><li><strong>Uncapped Upside (High Reward):</strong> <br>While the risk is locked low, if the AI works, we gain <strong>exponential efficiency improvements.</strong></li></ul><p>We are not handing our fate to AI. We treat AI as a <strong>“high odds, zero risk” add-on”.</strong></p><blockquote><strong><em>If the AI script fails? Fall back to manual; the result is the same. If it succeeds? It is a massive leap in efficiency.</em></strong></blockquote><h3>Implementation: Two Levels of AI Empowerment</h3><p>Understanding the advantage, how do we apply it? Many people think they must build a perfect automation framework immediately. In fact, QA can use AI at two levels:</p><h3>1. Basic Level: Atomic Tasks and “Disposable Code”</h3><p><strong>(Suitable for Junior QAE / Manual Testers)</strong></p><p>If your work currently relies on manual testing, don’t try to “turn 100% of test cases into code” right away. You should focus on tasks that are <strong>“tedious, repetitive, and low-brainpower.”</strong></p><p><strong>Examples:</strong></p><ul><li><strong>Log Analysis:</strong> Used to spend 5 minutes eyeing device logs for error codes? Now, spend 30 seconds letting AI write a Shell Script to catch them instantly.</li><li><strong>Data Generation:</strong> Need 100 rows of test data in a specific format? Let AI generate the CSV for you.</li></ul><p><strong>Why is AI so helpful at this level?</strong></p><p>First is the <strong>compounding effect</strong>. Let’s do the math: Suppose you analyze failed logs 20 times a day, taking 5 minutes each time. That is <strong>100 minutes (nearly 1.7 hours)</strong> spent on monotonous checking daily. If an AI script compresses this to 10 seconds, you gain <strong>1.6 hours of deep work time</strong> every day. Over a year, this saves the company <strong>two whole months of man-hours</strong>. This is the huge return from small progress.</p><p>Second is the <strong>extremely low validation cost</strong>. Since the scope is small, checking if the AI code works is very simple. Unlike the high cost of verifying product code, the trial-and-error cost for these atomic tasks is almost zero.</p><p>For these tasks, we can even adopt a <strong>“Disposable Code”</strong> mindset. They exist to replace that immediate hard labor.</p><ul><li>If it works, you save time.</li><li>If it breaks or expires, throw it away. Let AI generate a new one, or temporarily go back to manual.</li></ul><p>These fragmented tools are the “scaffolding” to automation. They help manual testers cross the fear of coding, gradually growing into engineers who can handle code through collaboration with AI.</p><h3>2. Advanced Level: Architecture and DAA</h3><p><strong>(Suitable for Senior QAE / SDET)</strong></p><p>When you and your team pass the basic stage and enter system-level automation, AI’s role shifts from “writer” to “copilot.”</p><p>At this stage, we can no longer rely on disposable code. We must build a robust architecture, such as <a href="https://medium.com/@gigayaya/declarative-action-architecture-a-scalable-pattern-for-e2e-automation-1f9a10d24ee0"><strong>Declarative Action Architecture (DAA)</strong></a>. Here, the QA’s duty is to define architecture, design interfaces, and set patterns, then let AI fill in the implementation details.</p><p>Some might challenge: “If internal products are full of bad AI code, it becomes a hidden threat.” This is where the Senior QA/SDET provides value. <strong>The higher the AI output efficiency, the more important Code Review becomes.</strong> We must ensure the automation code meets software engineering standards.</p><p>However, compared to developing formal products, the scope for QA automation is still much smaller.</p><p><strong>Why?</strong> Product code must handle high concurrency, strict security standards, and real-world attacks. QA test code usually runs in a controlled environment, facing predictable inputs and a single system state. It serves the company, not the world.</p><p>Therefore, a senior engineer using AI for automation faces much lower technical complexity than for formal products. This allows for exponential efficiency returns. It’s no longer just saving minutes; it can <strong>compress a 3-day manual Regression Cycle into 2 hours</strong>. The impact on the product release rhythm is revolutionary.</p><h3>Conclusion: The “Taste” AI Cannot Mimic</h3><p>Finally, you might ask: If AI can write code and tests, what is the future of QA?</p><p>This is a philosophical question. Engineers and AI pursue “logical correctness,” but QA pursues <strong>“quality of experience.”</strong></p><p>The final user of product is human, and only humans can understand human pain points and “taste.” AI can write perfect Assert statements, but it cannot tell us if a button feels “right” or if a flow makes the user feel “frustrated.”</p><p><strong>AI handles the logical 0s and 1s; QA guards the unquantifiable “human experience.”</strong></p><p>In the AI era, QA is no longer just an executor, but a designer holding a powerful lever. Use AI to handle 80% of the coding and chores, and focus your energy on the core value — keen insight into product quality. This is not just an efficiency upgrade; it is a reshaping of the QA career’s value.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c9ee6850c6d8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Declarative Action Architecture (DAA) Q&A]]></title>
            <link>https://medium.com/@gigayaya/declarative-action-architecture-daa-q-a-854e6c269105?source=rss-c2d0d65b1ac0------2</link>
            <guid isPermaLink="false">https://medium.com/p/854e6c269105</guid>
            <category><![CDATA[qa]]></category>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[design-patterns]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[test-automation]]></category>
            <dc:creator><![CDATA[Giga Chang]]></dc:creator>
            <pubDate>Sat, 06 Dec 2025 16:03:30 GMT</pubDate>
            <atom:updated>2025-12-06T16:11:34.572Z</atom:updated>
            <content:encoded><![CDATA[<p>In the previous articles, we introduced the basic concepts of <strong>Declarative Action Architecture (DAA)</strong>, the application of the Composite Pattern, and the mindset of treating it as an internal product.</p><p>During the actual adoption of DAA, developers often encounter questions regarding architectural trade-offs. This article compiles four common questions regarding efficiency, correctness, and maintainability, discussing how to view these design choices within the DAA pattern.</p><h3>Question 1: Are Action Names Too Long?</h3><h4>Q:</h4><p>DAA suggests using descriptive long names like upgrade_device_firmware_successfully_and_verify_version. Does this make stack traces difficult to read or affect the IDE autocomplete experience?</p><h4>A:</h4><p>In large-scale project practice, semantic long naming usually brings higher maintenance value:</p><ol><li><strong>Semantic Value of Stack Traces</strong> <br>When a test fails, a long name provides complete <strong>Semantic Context</strong>. For example, the error message Error in upgrade_device_firmware_successfully_and_verify_version allows developers to understand the &quot;expected behavior&quot; and the &quot;failure point&quot; without diving into the code when checking logs. This is more helpful for quickly locating issues compared to a short stack trace like fw_upg.</li><li><strong>IDE Support</strong> <br>Modern IDE Fuzzy Search features can effectively handle long name inputs. Developers only need to type keywords (such as upg fw or ver) to quickly locate the target function.</li><li><strong>Explicit Contract Declaration</strong> <br>Suffixes (like _and_verify) are not redundant words but a <strong>Contract</strong> with the user. It explicitly informs the Test Layer author that the Action already contains verification logic, eliminating the need to repeat assertions in the test, thereby reducing redundant code in test scripts.</li></ol><h3>Question 2: Does Mandatory Self-Verification Affect Execution Performance?</h3><h4>Q:</h4><p>DAA requires every Action to be self-verifying. If every operation (like create_user) requires an additional API call to confirm the result, will the accumulation significantly slow down the overall test execution speed?</p><h4>A:</h4><p>This is a trade-off between <strong>Machine Time</strong> and <strong>Engineering Time</strong>:</p><ol><li><strong>Correctness First</strong> <br>The core value of automation testing lies in the credibility of the results. Of course, adding verification steps does incur additional time costs, but in a scenario where correct test results are the top priority, this is an acceptable cost. More importantly, only through a mandatory and continuous self-verification mechanism can we possibly approach 100% test correctness, avoiding False Positives that destroy the team’s trust in automated testing.</li><li><strong>Marginal Cost Analysis</strong> <br>The time increase caused by extra verification is often controllable. We can usually calculate the time cost required for verification, and typically, this cost is acceptable and worthwhile in exchange for confidence in test results, especially in the pursuit of the highest level of correctness.</li></ol><h3>Question 3: Does Composite Action Increase Debugging Difficulty?</h3><h4>Q:</h4><p>After encapsulating multiple steps into a Composite Action, if a test fails, the Stack Trace Log only shows an error in that Composite Action. Does this create a “black box” effect, making it difficult for developers to locate exactly which internal step went wrong?</p><h4>A:</h4><p>DAA’s debugging visibility is built on the <strong>Self-Verification</strong> mechanism of <strong>Atomic Actions</strong>.</p><p>Since the underlying Atomic Actions must also self-verify, when a process fails at an intermediate step, that Atomic Action will throw a specific error. Therefore, the Stack Trace will point to the specific line of code that failed inside the Composite Action. As long as the discipline of layered verification is strictly followed, errors can be captured precisely without being hidden by encapsulation.</p><p>Furthermore, precisely because each function uses descriptive naming, the Stack Trace reads more like a clear execution path report. Developers can see at a glance what business intent was being executed when the process was interrupted, which is easier to read than a traditional flat script filled with meaningless locator operations:</p><pre>AssertionError: Expected payment success message was not found.<br>  at verify_payment_success_message_is_visible (actions/payment_actions.py:42)<br>  at submit_credit_card_payment_and_verify_success (actions/payment_actions.py:28)<br>  at complete_checkout_flow_and_verify_order_confirmation (actions/checkout_workflow.py:15)<br>  at test_guest_user_checkout_journey (tests/e2e/test_checkout.py:10)</pre><p><em>In this example, without looking at the source code, one can clearly read from the Stack Trace: the error occurred in the “Guest Checkout” journey, failing at the “Verify Success Message” step after “Submit Credit Card Payment”.</em></p><h3>Question 4: Does Negative Testing Lead to Code Duplication?</h3><h4>Q:</h4><p>If writing a “Login Failure” action, the operation flow is the same as “Login Success”, only the verification logic differs. Under the DAA pattern, does one need to duplicate the entire flow code to create a new Action? Does this violate the DRY (Don’t Repeat Yourself) principle?</p><h4>A:</h4><p>This is a trade-off point in the DAA pattern, where we tend to prioritize the independence and clarity of test code:</p><h4><strong>Implementation Duplication vs. Composition Duplication</strong></h4><p>We should distinguish between <strong>Implementation Duplication</strong> and <strong>Composition Duplication</strong>.</p><ul><li><strong>Implementation Duplication</strong> refers to the duplication of underlying logic such as Locators and API calls, which is already solved by encapsulation in the Atomic and Physical Layers in DAA.</li><li><strong>Composition Duplication</strong> refers to if login_success and login_fail both call the same sequence of functions like fill_username, fill_password, etc. This is merely a repetition of the &quot;declaration of step order&quot;, not the implementation logic. This duplication is acceptable because it makes the intent of each test case more independent and clear.</li></ul><h4><strong>Verification Logic Uniqueness (Single Point of Verification)</strong></h4><p>DAA does not oppose creating parameterized “Universal Actions” (like login(expect_success=False)), as long as the Action maintains sufficient descriptiveness and clarity. The key principle is <strong>not to have multiple Actions repeating the implementation of the same business verification logic</strong>. In this example, although login_success and login_fail have similar execution steps, they verify completely different business results (entering home page vs showing error). This means they each maintain different business contracts. As long as we ensure that the verification logic for each business rule is converged (e.g., all logic verifying login success is handled by the same Action), then whether to write different results separately for simplicity or combine them for unity are both acceptable design choices.</p><h3>Conclusion</h3><p>The design intent of the DAA pattern is clear and distinct: <strong>To make every effort to improve code Readability and Scalability under the premise of ensuring absolute test Correctness.</strong></p><p>It is not aimed at solving all problems but provides a structured approach to managing the complexity of automated testing. Through explicit guidelines on naming, verification mechanisms, and code structure, we hope to establish an automated testing product that is both trustworthy and easy to maintain and use long-term.</p><p>Finally, it must be emphasized again that for automated testing, correctness is the unshakable cornerstone. Once the correctness of results cannot be guaranteed, any optimization of speed or architecture loses its meaning. All design trade-offs in DAA ultimately serve this highest guiding principle — building firm trust in test results.</p><p>Check out the full demo code on <a href="https://github.com/gigayaya/declarative-action-architecture-demo">https://github.com/gigayaya/declarative-action-architecture-demo</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=854e6c269105" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Product Thinking in Automation Testing: Why the DAA Action Layer is More Like an SDK Than a Bag of…]]></title>
            <link>https://medium.com/@gigayaya/product-thinking-in-automation-testing-why-the-daa-action-layer-is-more-like-an-sdk-than-a-bag-of-82193d264727?source=rss-c2d0d65b1ac0------2</link>
            <guid isPermaLink="false">https://medium.com/p/82193d264727</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[design-patterns]]></category>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[automation]]></category>
            <category><![CDATA[qa]]></category>
            <dc:creator><![CDATA[Giga Chang]]></dc:creator>
            <pubDate>Mon, 01 Dec 2025 14:48:55 GMT</pubDate>
            <atom:updated>2025-12-02T16:28:41.820Z</atom:updated>
            <content:encoded><![CDATA[<h3>Product Thinking in Automation Testing: Why the DAA Action Layer is More Like an SDK Than a Bag of Tools</h3><p><em>This is Part 3 of the Declarative Action Architecture (DAA) series. This article shifts the perspective, focusing less on framework details and more on one thing: </em><strong><em>Treating the Action Layer as an “Internal SDK for QA / Dev” — that is, a product interface you are responsible for managing.</em></strong><em> Starting from this premise, we will rethink naming, interface design, and how to make trade-offs between these and coding style guidelines.</em></p><p>In practice, many QAs / SDETs adopt this mindset when writing automation tests:</p><blockquote><em>“I’m just making a set of convenient testing tools for the team.”</em></blockquote><p>As a result, the code looks like this:</p><ul><li>A utils.py here, a helpers_new.py there</li><li>Action names are compressed to be very short to fit coding styles</li><li>A bunch of utility functions are thrown into the actions/ folder, added by anyone whenever they feel like it</li><li>As long as “this test passes right now,” it counts as a success</li></ul><p>This approach looks efficient in the short term, but it has a huge side effect:</p><blockquote><em>When you treat automation testing as a “tool”, you naturally maintain it with the standards of “writing small tools”, rather than the standards of “managing a product”.</em></blockquote><p>In Declarative Action Architecture (DAA), I want to propose another perspective:</p><blockquote><em>The automation test framework you write </em><strong><em>is itself a product you are responsible for</em></strong><em>. You are not “writing a few tests”; you are designing a “product for QA / Dev use”.</em></blockquote><p>Once you accept this premise, many things start to change, including:</p><ul><li>You will care about the “User Experience” of this framework</li><li>You will think about “Version Evolution, Compatibility, API Design”</li><li>You will also realize: <strong>Although the form of the Action Layer is code files, its essence is your product interface, so you cannot view it solely through “code standards”.</strong></li></ul><p>So this article wants to discuss two things:</p><ol><li>QA / SDET should treat the Action Layer as an “Internal Product / SDK”, not a bag of tools.</li><li>Since it is a product, even if its presentation is code, it should be judged by the standard of “is the product clear and easy to use”, rather than being completely bound by coding style guidelines. For example: to make an Action name clearly express intent, exceeding 79 characters is an acceptable trade-off.</li></ol><h3>1. Automation Testing Itself is a “Product”</h3><p><strong>TL;DR: Treat automation as a product, and the standard shifts from “it runs” to “it’s easy to use and handover”.</strong></p><p>What does “treating automation as a product” mean? Let’s compare the Tool Mindset vs. Product Mindset:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0me3sWNB_VDS1LLDASSf5g.png" /><figcaption>Tool Mindset vs. Product Mindset</figcaption></figure><p>Suppose you are responsible for an external API or SDK in a company, you probably wouldn’t do this:</p><ul><li>Randomly naming endpoints: /do_stuff_v2</li><li>Changing the response format whenever you feel like it, ignoring if old clients break</li></ul><p>But in many teams, <strong>automation testing frameworks are treated exactly like this</strong>.</p><p>The DAA Action Layer is actually very much like an “SDK for Test Authors”:</p><ul><li>Test Layer = Client program (the person writing the scenario)</li><li>Action Layer = SDK / API (the interface you designed)</li><li>Physical Layer = Underlying implementation like driver / HTTP / locator</li></ul><p>When I say “like an SDK”, I don’t mean “it must look like a specific library”, but rather:</p><ul><li>It is a set of <strong>stable external function interfaces</strong></li><li>It has clear naming and clear behavior, allowing others to call it safely</li><li>It is “used as a black box” by many different test cases</li><li>When designing it, you think about “How will users use it? How to avoid pitfalls?”</li></ul><p>Just as a general SDK is a collection of APIs for developers to call, the Action Layer is the <strong>Test API Collection</strong> you provide to the entire QA / Dev team.</p><p>If you acknowledge “I am the owner of this SDK”, your priorities naturally change:</p><ul><li>You no longer just ask “Is writing it this way faster?” You start asking “Will others understand this design six months from now?”</li><li>You no longer just ask “Is this function useful to me right now?” You ask “Do I want everyone in the team to use the same Action?&quot;</li><li>You no longer just ask “Does it comply with coding style?” You ask “Is this name clear to the user (test author)? Is it misleading?”</li></ul><p>This is why I say: <strong>For QA / SDET, automation testing is not just a technical achievement, but a product responsibility.</strong></p><h3>2. Action Layer = “Internal SDK” for QA / Dev</h3><p><strong>TL;DR: The Action Layer is a set of stable test APIs, not a pile of scattered helpers.</strong></p><p>From the DAA perspective, the role of the Action Layer is actually very clear:</p><blockquote><em>It is not a blob of helpers, but a set of “APIs used to describe business actions”.</em></blockquote><p>You can correspond them like this:</p><p>Traditional API WorldCorrespondence in DAAPublic API endpointAction / Composite ActionSDK UserTest Layer, other internal toolsAPI ContractAction name, parameters, behavior, and failure semantics</p><p>This means when you write an Action, it&#39;s not just:</p><blockquote><em>“I want to extract these steps for reuse.”</em></blockquote><p>But rather:</p><blockquote><em>“I am currently designing an API like </em><em>upgrade_device_firmware_successfully(...), and all future tests will stand on this API, trusting it and relying on it.&quot;</em></blockquote><p>Once you think this way, your requirements for the Action Layer become closer to designing an SDK:</p><ul><li>Naming should reflect “Intent”, not “Implementation Details”</li><li>Behavior should be stable and predictable</li><li>Failures should have clear messages, not just “assertion failed”</li><li>Changes should be disciplined, don’t arbitrarily break existing tests</li><li>Typing actions. to see autocomplete is like looking at a &quot;Product API Catalog&quot;</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xvMPtxwM4Z1aXNQ57ozpQQ.png" /><figcaption>Easily browse the list of APIs provided by the Action Layer</figcaption></figure><p>To speak in product language: <strong>The Action Layer is the “User Interface” you provide to QA / Dev.</strong> This interface just happens to be presented in the form of “code”.</p><h3>3. Form is “Code”, Essence is “Product Interface”</h3><p><strong>TL;DR: In the Action Layer, a function is actually a product API, not merely an implementation detail.</strong></p><p>Here we discuss a key concept:</p><blockquote><em>Since the Action Layer is your “Product”, although its form is code files, it cannot be treated just as “general code”.</em></blockquote><p>Take PEP 8 (Python’s official style guide) as an example, it suggests:</p><ul><li>Single line code length should not exceed 79 characters (or 88, depending on team settings)</li></ul><p>This principle is very useful in general software development:</p><ul><li>Clear Diffs</li><li>Side-by-side reviews don’t explode the layout</li><li>Many tools/editors also default to wrapping lines at this length</li></ul><p>But at the Action Layer level, what you are designing is actually a <strong>Product’s External Interface</strong>. At this moment, the first priority question you face is not:</p><blockquote><em>“Does this line have 80 characters?”</em></blockquote><p>But:</p><blockquote><em>“Can someone seeing this name instantly understand what this </em><em>Action is doing?&quot;</em></blockquote><p>Starting from this angle, certain coding guidelines are no longer absolute hard rules, but become references that need to be <strong>traded off</strong>:</p><ul><li>Formally: It is a function definition</li><li>Essentially: It is a “Product API” you provide for team use</li></ul><p>So you start to see design choices like this:</p><pre># Easier to fit line length norms, but intent is vague<br>def fw_upg_v2(dev, ver):<br>    ...<br><br># Name is longer, might need line wrapping, but intent is very clear<br>def upgrade_device_firmware_successfully_and_verify_version(<br>    device_id: str,<br>    target_version: str,<br>):<br>    ...</pre><h3>Seeing the Difference in Naming from the Test Layer Perspective</h3><p>The same test scenario:</p><blockquote><em>“Upgrade the device to 1.2.3, and verify the upgrade is successful.”</em></blockquote><p>If the Test Layer uses the first naming style, the test might look like this:</p><pre>def test_upgrade_to_latest_version():<br>    fw_upg_v2(dev, &quot;1.2.3&quot;)<br>    assert dev.version == &quot;1.2.3&quot;</pre><p>When a Reviewer or a new colleague looks at this test, their brain has to think about several things at once:</p><ul><li>What exactly did fw_upg_v2 do? Did it include a reboot? Did it wait for the device to be online?</li><li>Why do we need to assert dev.version afterwards? Is it because fw_upg_v2 doesn&#39;t verify the result? Or is it just redundant?</li><li>If the upgrade process changes in the future, should I change fw_upg_v2, or change this test, or both?</li></ul><p>Switching to the second naming style, the Test Layer becomes:</p><pre>def test_upgrade_to_latest_version():<br>    actions.upgrade_device_firmware_successfully_and_verify_version(<br>        device_id=dev.id,<br>        target_version=&quot;1.2.3&quot;,<br>    )</pre><p>At this point, the Reviewer’s cognitive load is much smaller:</p><ul><li>Instantly know what the “Intent” of this scenario is: <strong>“Upgrade, and verify success”</strong>, not “do some upgrade related operations”.</li><li>No need to chase into the Action to know it will verify version, status, and other post-conditions itself.</li><li>If the upgrade process changes in the future, just by seeing the function name upgrade_device_firmware_successfully_and_verify_version, I know I should go to the Action Layer to modify the implementation, without needing to go back and modify every Test Case that calls it.</li></ul><p>For the same two or three lines of code, the first style relies on “you knowing the project history” and “you having seen the implementation”, the second style allows the Test Layer itself to carry <strong>Specification Semantics</strong>.</p><p>From the Test Layer’s perspective:</p><ul><li>Style 1: <strong>Reading Code</strong> (Need to reconstruct details)</li><li>Style 2: <strong>Reading Specs</strong> (Describing intent and expectation)</li></ul><p>And what DAA wants to do is to let the Test Layer fall into the second state as much as possible.</p><h3>4. PEP 8 vs. Readability: How to Trade-off, What is the Priority?</h3><p><strong>TL;DR: At this layer, naming and readability come first, pretty formatting comes second.</strong></p><p>Let’s use a more complete example to look at the trade-off between PEP 8 line length norms vs. readability, and discuss what is a more reasonable priority at the Action Layer level.</p><p>Suppose you want to design an Action to express this behavior:</p><blockquote><em>“Upgrade the device to a specified version, and verify the upgrade is successful, if it fails, throw a clear error.”</em></blockquote><h3>Naming with “Line Length Priority”</h3><pre>def fw_upg_v2(dev, ver):<br>    ...</pre><p>From a tool perspective:</p><ul><li>Short name, won’t break PEP 8 line length</li><li>Looks very neat in some editors</li></ul><p>But from a user perspective:</p><ul><li>Newcomers have no idea if fw is firmware or firewall</li><li>What does v2 represent? Does v1 still exist? Will there be a v3 in the future?</li><li>Looks like a black box in the Test Layer: “It did something, but I don’t know what it did”</li></ul><h3>Naming with “Intent Expression Priority”</h3><pre>def upgrade_device_firmware_successfully_and_verify_version(<br>    device_id: str,<br>    target_version: str,<br>):<br>    ...</pre><p>From a tool perspective:</p><ul><li>Function name will be long, needs line wrapping, formatter might complain a bit</li></ul><p>But from a product interface perspective:</p><ul><li>Users can understand the intent almost without looking at the docstring</li><li>Reads like a complete sentence in the test, close to DSL / Specification Language</li><li>Reviewer looks at the Test Layer and knows what this Action is responsible for without looking at the implementation</li></ul><p>If you accept the premise that “Action Layer is your product interface”, then the trade-off here becomes reasonable:</p><blockquote><em>At this level, </em><strong><em>I would rather “not follow the line length rule so perfectly”, in exchange for an interface that is clearer and harder to misunderstand for the user.</em></strong></blockquote><p>A very important point here is:</p><ul><li>We are not claiming “coding principles are unimportant”</li><li>Nor are we encouraging everyone to casually ignore the team’s style guide,</li><li>But we are clarifying: <strong>At the Action Layer, this “Product Layer”, what is the priority goal.</strong></li></ul><p>That is to say: <strong>Coding standards are of course important, but they serve “code maintainability”; but in the Action Layer, we have an additional dimension: This is a “Product Interface”.</strong></p><h3>5. Behavioral Contract greater than Format Contract: Spend Effort in the Right Place</h3><p><strong>TL;DR: Compared to perfect formatting, it is more important to clearly state “what behavior this Action promises”.</strong></p><p>Back to the core of DAA: The real value of the Action Layer lies in it being a set of “behavioral contracts”.</p><ul><li>Each Action promise &quot;I will complete a certain business action for you, and verify success&quot;</li><li>The Test Layer can stand on these Actions and describe acceptance specs in high-level language</li></ul><p>If most of the team’s discussion is stuck on:</p><ul><li>Should this line be 80 or 88 characters?</li><li>Should this bracket be wrapped?</li></ul><p>But there is no consensus on the following questions:</p><ul><li>What are the pre-conditions / post-conditions of this Action?</li><li>When it fails, is the error message specific enough and easy to debug?</li><li>When the business process changes in the next version, should the contract of this Action evolve with it? If so, how?</li></ul><p>Then the effort is actually being placed in the wrong place.</p><p>Product thinking pulls the weight back:</p><blockquote><em>“The effort I spend on naming, behavior design, and contract stability, should be far greater than the effort spent on formatting details.”</em></blockquote><p>Format is the foundation, but not the destination. Especially at the Action Layer level, what we care about is: <strong>Is this a good product interface</strong>.</p><h3>6. Conclusion: When You Treat the Test Framework as a Product, Many DAA Choices Become Reasonable</h3><p>If you only treat automation testing as a small tool that “just needs to pass”, DAA will look a bit “over-engineered”:</p><ul><li>Why split into three layers?</li><li>Why must Actions be self-verifying?</li><li>Why can’t the Test Layer be filled with raw steps?</li><li>Why do Action names have to be so long?</li></ul><p>But if you are willing to change your perspective:</p><blockquote><strong><em>“I am the Product Owner of this test framework”</em></strong></blockquote><p>Then many designs become natural:</p><ul><li>Test Layer needs to be readable, like a spec → Because that is your “Product UI”</li><li>Action Layer needs to have stable APIs → Because that is your “Internal SDK”</li><li>Sometimes for a clear interface, naming can be a bit longer → Because it’s friendlier to the user</li><li>Certain coding norms can be flexible in specific contexts → Because you know you are making trade-offs for the product, not being lazy</li></ul><p>What you write is no longer just “some automation scripts”, but a <strong>product that the team uses every day and can be handed over to the next generation of colleagues</strong>.</p><p>And DAA simply provides you with a more structured, more principled way to design this product.</p><p>Check out the full demo code on <a href="https://github.com/gigayaya/declarative-action-architecture-demo">https://github.com/gigayaya/declarative-action-architecture-demo</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=82193d264727" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Scaling DAA: Mastering the Action Layer with Composite Patterns]]></title>
            <link>https://medium.com/@gigayaya/scaling-daa-mastering-the-action-layer-with-composite-patterns-ae845de7ee72?source=rss-c2d0d65b1ac0------2</link>
            <guid isPermaLink="false">https://medium.com/p/ae845de7ee72</guid>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[qa]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[design-patterns]]></category>
            <category><![CDATA[automation]]></category>
            <dc:creator><![CDATA[Giga Chang]]></dc:creator>
            <pubDate>Fri, 28 Nov 2025 16:26:02 GMT</pubDate>
            <atom:updated>2025-12-06T16:11:42.430Z</atom:updated>
            <content:encoded><![CDATA[<p><em>In Part 1, we introduced the Declarative Action Architecture (DAA) as a foundation for readable and reliable E2E tests. Now, we dive deeper into the Action Layer to explore a strategy that separates good automation from great automation: The Composite Action Pattern.</em></p><p>As automation engineers, we often hit a plateau. We’ve successfully separated our tests from our logic (using Page Objects or DAA), and our tests are passing. But as the suite grows from 50 to 500 scenarios, a new set of problems emerges:</p><ul><li><strong>Repetition</strong>: You find yourself calling the same sequence of five actions in twenty different tests.</li><li><strong>Fragility</strong>: A change in a business workflow requires updating dozens of test files.</li><li><strong>Cognitive Load</strong>: Reading a test case requires mentally stitching together too many small steps to understand the “big picture.”</li></ul><p>The solution isn’t just <em>more</em> abstraction; it’s <em>structured</em> abstraction. Enter the <strong>Composite Action Pattern</strong>.</p><h3>The Hierarchy of Actions</h3><p>In a mature DAA implementation, not all actions are created equal. We can categorize them into two distinct levels:</p><h4>Level 1: Atomic Actions (The Bricks)</h4><p>These are the fundamental units of interaction. They do exactly one thing and verify it.</p><ul><li><em>Examples</em>: create_user, click_login_button, verify_modal_closed.</li><li><em>Key Features</em>: Reusable, generic, and unaware of complex business context.</li></ul><h4>Level 2: Composite Actions (The Structures)</h4><p>These are high-level business workflows composed of multiple Atomic Actions. They represent <em>user goals</em> rather than <em>system interactions</em>.</p><ul><li><em>Examples</em>: onboard_new_customer, complete_checkout_flow, perform_device_upgrade.</li><li><em>Key Features</em>: Specific to business logic, composed entirely of Level 1 actions.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/969/1*WRqNEniJfS0d4N1LpZq7jA.png" /><figcaption>The DAA Maintenance Model: Composite vs. Atomic Scope</figcaption></figure><h3>Real-World Example: The Device Upgrade Flow</h3><p>Let’s imagine a scenario where we need to test a “Device Upgrade” feature. The business logic requires:</p><ol><li>Checking the old device’s data.</li><li>Creating a new device with that migrated data.</li><li>Recycling (deleting) the old device.</li><li>Verifying the old device is gone.</li></ol><h4>The “Anti-Pattern” (Flat Structure)</h4><p>Without Composite Actions, your Test Layer might look like this:</p><pre>def test_upgrade_flow(self):<br>    # Too many details exposed in the test!<br>    old_phone = self.create_object_and_verify(...)<br>    old_data = self.get_object_data(old_phone)<br>    <br>    new_phone = self.create_object_and_verify(..., data=old_data)<br>    self.delete_object_and_verify(old_phone[&#39;id&#39;])<br>    self.get_object_and_expect_not_found(old_phone[&#39;id&#39;])<br>    <br>    assert new_phone[&#39;data&#39;] == old_data</pre><p>This is readable, but it’s <strong>leaky</strong>. The test knows too much about <em>how</em> an upgrade happens. If the upgrade process changes (e.g., a new step is added), you have to update every test that performs an upgrade.</p><h4>The Composite Approach</h4><p>We encapsulate this logic in the Action Layer.</p><pre># lib/action_layer.py<br><br>def perform_device_upgrade(self, url, old_device_id, new_device_name):<br>    &quot;&quot;&quot;<br>    Composite Action: Simulates a full device upgrade flow.<br>    &quot;&quot;&quot;<br>    # 1. Read (Atomic)<br>    old_device = self.get_object_and_verify(url=url, obj_id=old_device_id)<br>    old_device_data = self.get_object_data(object_data=old_device)<br>    <br>    # 2. Create (Atomic)<br>    new_device = self.create_object_and_verify(<br>        url=url, <br>        name=new_device_name, <br>        data=old_device_data<br>    )<br>    <br>    # 3. Delete (Atomic)<br>    self.delete_object_and_verify(url=url, obj_id=old_device_id)<br>    <br>    # 4. Verify (Atomic)<br>    self.get_object_and_expect_not_found(url=url, obj_id=old_device_id)<br>    <br>    # Self-Verification of the Composite Action<br>    assert self.get_object_name(new_device) == new_device_name<br>    assert self.get_object_data(new_device) == old_device_data<br>    <br>    return new_device</pre><p>Now, look at the Test Layer:</p><pre># tests/test_composite_action.py<br><br>def test_upgrade_old_phone_to_new_phone(self):<br>    # Setup<br>    old_phone = self.create_object_and_verify(...)<br>    old_id = self.get_object_id(old_phone)<br><br>    # Action: One line, full business logic<br>    self.perform_device_upgrade(<br>        url=self.DEMO_URL, <br>        old_device_id=old_id, <br>        new_device_name=&quot;iPhone 15&quot;<br>    )</pre><h3>Why This Strategy Wins</h3><h4>1. The “Single Point of Truth”</h4><p>If the business decides that “Upgrading” now also involves sending an email confirmation, you don’t touch the 50 tests that use the upgrade flow. You update perform_device_upgrade once, and all tests automatically inherit the new logic.</p><h4>2. Compose, Don’t Repeat</h4><p>We are effectively building a Domain-Specific Language (DSL) for our application.</p><ul><li>Need to create a user? Use an Atomic Action.</li><li>Need to create a user, verify their email, and add a credit card? Compose those three Atomic Actions into a setup_verified_customer Composite Action.</li></ul><h4>3. Debugging is Layered</h4><ul><li>If create_object fails, you know the API endpoint is broken (Physical/Atomic issue).</li><li>If perform_device_upgrade fails but the individual API calls pass, you know the <em>business logic</em> or <em>workflow</em> is broken (Logic issue).</li></ul><h4>4. Readable by Design</h4><p>By composing functions into high-level actions, we create tests that speak the user’s language. Instead of click_button_a, wait_for_b, input_text_c, we have upgrade_device. As the framework scales, this conversational style empowers any team member to intuitively understand existing logic and easily compose new actions they need from these high-level building blocks.</p><h3>Conclusion</h3><p>The Declarative Action Architecture isn’t just about moving code around; it’s about <strong>modeling your automation to match your business domain</strong>.</p><p>By adopting the Composite Action pattern, you transform your Action Layer from a flat list of commands into a rich, semantic library of business behaviors. This is how you build test suites that don’t just survive change — they thrive on it.</p><p>Check out the full demo code on <a href="https://github.com/gigayaya/declarative-action-architecture-demo">https://github.com/gigayaya/declarative-action-architecture-demo</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ae845de7ee72" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Declarative Action Architecture: A Scalable Pattern for E2E Automation]]></title>
            <link>https://medium.com/@gigayaya/declarative-action-architecture-a-scalable-pattern-for-e2e-automation-1f9a10d24ee0?source=rss-c2d0d65b1ac0------2</link>
            <guid isPermaLink="false">https://medium.com/p/1f9a10d24ee0</guid>
            <category><![CDATA[qa]]></category>
            <category><![CDATA[test-automation]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-testing]]></category>
            <dc:creator><![CDATA[Giga Chang]]></dc:creator>
            <pubDate>Fri, 21 Nov 2025 17:21:36 GMT</pubDate>
            <atom:updated>2025-12-09T06:21:06.180Z</atom:updated>
            <content:encoded><![CDATA[<h3>Declarative Action Architecture: A Scalable Pattern for E2E Automation Testing</h3><p>End-to-End (E2E) testing is a critical part of the software development lifecycle. However, as test suites grow, maintaining stability and readability can become a significant challenge. In this article, I will introduce the <strong>Declarative Action Architecture (DAA)</strong>, a design pattern aimed at improving the scalability and reliability of automation projects.</p><p>While tool selection is important, the underlying <strong>architecture</strong> often plays a more critical role in the long-term success of an automation suite.</p><p>To address these common issues, I have refined a pattern that focuses on enhancing <strong>readability</strong> and <strong>trust</strong>: the <strong>Declarative Action Architecture (DAA)</strong>.</p><h3>The Challenge: Procedural Scripts</h3><p>Many automation projects begin with simple scripts. While this approach works initially, it can lead to fragility as the suite grows.</p><ul><li><strong>Logic leaks into tests:</strong> Loops and conditionals make tests hard to read.</li><li><strong>False positives:</strong> A test passes, but did it actually <em>do</em> anything? (e.g., clicking “Save” without checking if the save happened).</li><li><strong>Maintenance overhead:</strong> A UI change may require updating multiple test files.</li></ul><p>The Page Object Model (POM) helps, but it often becomes a dumping ground for mixed responsibilities. We need something stricter.</p><h3>The Approach: Declarative Action Architecture</h3><p>DAA is an evolution of the layered architecture. It enforces a strict separation of concerns into three distinct layers: <strong>Test</strong>, <strong>Action</strong>, and <strong>Physical</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Pbpevy8pCZurN_oEz8AkZw.png" /></figure><h3>1. The Test Layer (The “What”)</h3><p>The Test Layer should be <strong>100% declarative</strong>. It describes <em>what</em> the user is doing, not <em>how</em>.</p><p><strong>Rule:</strong> No logic allowed. No loops, no if statements, no direct API/UI calls.</p><p>This makes your tests read like documentation. Even a Product Manager should be able to read this and understand exactly what is being tested.</p><pre># tests/test_demo.py<br><br>class TestAPI(BaseAPITest):<br>    <br>    def test_get_request_success(self):<br>        # Clear, readable, and self-explanatory<br>        self.request_by_get_and_success(self.DEMO_URL)</pre><h3>2. The Action Layer (The “How” + Verification)</h3><p>This is the heart of DAA. The Action Layer translates the declarative steps from the Test Layer into execution logic.</p><p><strong>Rule 1: Self-Verification.</strong> Every action method <em>must</em> verify its own success. You never just “click button”; you “click button and verify modal opens.” This eliminates false positives.</p><p><strong>Rule 2:</strong> No direct interaction with the system. It delegates execution to the Physical Layer.</p><p><strong>Rule 3: Compose, Don’t Repeat.</strong> Complex business logic should be built by composing smaller, reusable “Atomic Actions” (Level 1) into “Composite Actions” (Level 2). This maximizes code reuse and ensures that if a low-level mechanism changes, you only need to update one Atomic Action.</p><pre># lib/action_layer.py<br><br>class BaseAPITest:<br>    <br>    def request_by_get_and_success(self, url, params=None, headers=None):<br>        # 1. Delegate execution to Physical Layer<br>        response = self.api_client.get(url, params=params, headers=headers)<br>        <br>        # 2. Self-Verification (The &quot;Assert&quot; is built-in)<br>        # We guarantee that if this line passes, the action was TRULY successful.<br>        http_status = response.status_code<br>        assert http_status == 200, f&quot;Expected status code 200, got {http_status}&quot;</pre><h3>3. The Physical Layer (The Mechanism)</h3><p>This layer is the “dumb” driver. It knows how to talk to the system (HTTP requests, WebDriver commands) but knows nothing about your business logic.</p><p><strong>Rule:</strong> Pure execution. No assertions, no business logic.</p><pre># lib/physical_layer.py<br><br>class APIClient:<br>    <br>    def get(self, url, params=None, headers=None):<br>        # Pure wrapper around the library (e.g., requests, selenium)<br>        return self.requester.get(url, params=params, headers=headers)</pre><h3>Why This Works</h3><h3>1. Increased Trust</h3><p>Because every action in the Action Layer verifies itself, we can be confident that a passing step implies a successful action. If login_and_success() passes, it confirms the user is logged in.</p><h3>2. Speed</h3><p>Writing new tests becomes a matter of assembling existing Lego blocks. You don’t need to write low-level code; you just compose high-level actions.</p><h3>3. Maintainability</h3><ul><li><strong>UI/API changes?</strong> Update the Physical Layer.</li><li><strong>Business logic changes?</strong> Update the Action Layer.</li><li><strong>Scenario changes?</strong> Update the Test Layer.</li></ul><h3>Conclusion</h3><p>By adopting the Declarative Action Architecture, we shift from writing procedural scripts to building a robust testing platform. This approach helps transform tests into living documentation, reduces maintenance costs, and increases confidence in the build pipeline.</p><p>In next chapter, I will talk about the strategy of Action Layer.</p><p><a href="https://medium.com/@gigayaya/scaling-daa-mastering-the-action-layer-with-composite-patterns-ae845de7ee72">Scaling DAA: Mastering the Action Layer with Composite Patterns</a></p><p>Check out the full demo code on <a href="https://github.com/gigayaya/declarative-action-architecture-demo">https://github.com/gigayaya/declarative-action-architecture-demo</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1f9a10d24ee0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Is This a Bug or Feature or By Design? Notes from a QA Working in the Imperfect World]]></title>
            <link>https://medium.com/@gigayaya/is-this-a-bug-or-feature-or-by-design-notes-from-a-qa-working-in-the-real-world-9218b1c07ca7?source=rss-c2d0d65b1ac0------2</link>
            <guid isPermaLink="false">https://medium.com/p/9218b1c07ca7</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[quality-assurance]]></category>
            <dc:creator><![CDATA[Giga Chang]]></dc:creator>
            <pubDate>Fri, 25 Jul 2025 13:28:20 GMT</pubDate>
            <atom:updated>2025-11-21T17:22:33.864Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>When QA detects an anomaly, how do we decide whether it’s a bug, a feature, or simply “by design”?</strong></p><h3>1. Introduction: Is this statement actually correct?</h3><p><em>“Any issue found by QA using a test case should be considered a bug, not a feature or by design.”</em></p><p>This is a statement commonly heard in many software development teams. For some QA engineers, it’s a guiding principle of quality. For some developers, it might seem overly rigid.</p><p>This article doesn’t aim to judge whether the statement is right or wrong. Instead, it examines the engineering implications behind it, its applicability and limitations in different situations, and the role boundaries between QA, development, and design.</p><h3>2. The Ideal QA Environment</h3><p>In a perfect software development workflow, the following conditions might hold:</p><blockquote>All requirements are well-documented and version-controlled</blockquote><blockquote>Every design or implementation change is traceable</blockquote><blockquote>Test cases are always up-to-date and reflect current specifications</blockquote><blockquote>Everyone shares a common understanding of expected behaviors</blockquote><p>Under such conditions, if a test case fails, it logically indicates that the implementation deviates from the design — hence, it qualifies as a bug.</p><p>In this context, the statement above is true. However, it is also trivial: a tautology. In reality, such pristine conditions are rare and hard to sustain.</p><h3>3. Challenges in Real-World Workflows</h3><p>In actual development environments, the following are more common:</p><blockquote>Requirements change frequently and aren’t always communicated to QA</blockquote><blockquote>Design decisions happen informally, with no documentation</blockquote><blockquote>Tests may be based on outdated specs, leading to false positives</blockquote><blockquote>Side effects in code unintentionally alter system behavior</blockquote><p>These factors create ambiguity between what’s considered a bug and what’s an intentional change.</p><p>Unconditionally enforcing the original statement can lead to unnecessary friction. Ignoring it completely, on the other hand, risks allowing undocumented deviations to accumulate unchecked.</p><h3>4. Three Real-World Scenarios</h3><h3>Scenario 1: Marked “by design,” but no design reference exists</h3><blockquote>A test case fails. The developer responds, “This is by design.” When QA asks for documentation, none is provided.</blockquote><p>Here, the test case was written based on current, traceable requirements. Without design evidence, the claim of “by design” lacks verification. In such a case, treating it as a bug until clarified is a reasonable course.</p><h3>Scenario 2: Informal agreement, no record</h3><blockquote>The developer explains that the behavior was discussed and agreed upon with architects and PMs, but no written record exists.</blockquote><p>While such informal consensus is common in fast-moving teams, from a QA perspective, it creates a traceability gap. If the test case is based on official requirements, then the observed behavior deviates from those expectations.</p><p>In this case, it’s advisable to log the discrepancy and request formal documentation before updating any test logic.</p><h3>Scenario 3: A side effect considered beneficial</h3><blockquote>A recent code change introduced a side effect that alters system behavior. The developer acknowledges it’s unintended but believes the result is beneficial to users, and requests QA to revise the test case accordingly.</blockquote><p>While the intent is understandable, QA’s responsibility is to validate based on approved design. Until that design is updated, this behavior remains undocumented and therefore outside test coverage scope.</p><p>In such cases, the appropriate course is to treat the anomaly as a bug and initiate a discussion on whether it should be formally accepted and documented.</p><h3>5. Extended Questions: Deviation Value and QA’s Role</h3><h3>If a behavior benefits the user, is it still a bug?</h3><p>In engineering terms, a bug is defined by deviation from expected behavior, not by whether the result is “good” or “bad.”</p><p>Even positive deviations should be reviewed, approved, and documented. Otherwise, they weaken test coverage reliability and long-term maintainability.</p><h3>Is QA part of the design process?</h3><p>QA may not lead design decisions, but they are responsible for verifying that implementation matches design intent. That means QA needs to:</p><blockquote><em>Validate traceability between behavior and requirements</em></blockquote><blockquote><em>Request evidence when changes are claimed “by design”</em></blockquote><blockquote><em>Update test cases only after formal approval of behavior changes</em></blockquote><p>In this sense, QA acts as a gatekeeper for design legitimacy, even if not a primary decision-maker.</p><h3>6. Between Ideal and Reality: How Should We See This Statement?</h3><p><em>“Any issue found by QA using a test case should be considered a bug.”</em></p><p>In a perfect world, it’s a self-evident truth. In the real world, it often sparks discussion or even conflict.</p><p>Software development is inherently iterative and imperfect. Requirements may shift, documentation may lag, and discussions may go unrecorded.</p><p>When a test fails, it’s not just a binary verdict of right or wrong — it’s often a signal. It invites a review: Was this behavior intentional? Is it documented? Is it truly what we want?</p><p>Working in an imperfect environment doesn’t mean abandoning standards. Nor does it mean declaring every anomaly a bug. Rather, it means maintaining the discipline to treat test failures as opportunities to revalidate shared understanding.</p><p>We may not reach the ideal state every day, but we can move closer to it by documenting decisions, updating expectations, and communicating across roles.</p><p>That might be the most stable way to pursue quality in an unstable world.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9218b1c07ca7" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>