<?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 Sabrina Miao on Medium]]></title>
        <description><![CDATA[Stories by Sabrina Miao on Medium]]></description>
        <link>https://medium.com/@sabrinamsh?source=rss-15ffbc76f40e------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*ThYddKliJM8bdTpb.</url>
            <title>Stories by Sabrina Miao on Medium</title>
            <link>https://medium.com/@sabrinamsh?source=rss-15ffbc76f40e------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 18:06:23 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@sabrinamsh/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[One Stack, Ten Repos: What Changed for Developer Experience]]></title>
            <link>https://medium.com/@sabrinamsh/one-stack-ten-repos-what-changed-for-developer-experience-fe0c35256217?source=rss-15ffbc76f40e------2</link>
            <guid isPermaLink="false">https://medium.com/p/fe0c35256217</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[developer-experience]]></category>
            <category><![CDATA[engineering-mangement]]></category>
            <category><![CDATA[softwar-development]]></category>
            <dc:creator><![CDATA[Sabrina Miao]]></dc:creator>
            <pubDate>Thu, 05 Nov 2026 09:52:08 GMT</pubDate>
            <atom:updated>2026-11-16T09:12:48.315Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CHgoxx0fRgrDYzkSFub22w.jpeg" /></figure><p><em>Why timing mattered when consolidating our codebases, and how AI turned it into a job one developer could finish.</em></p><p>When I joined, I noticed that almost every repo was set up differently.</p><p>Some used npm, some used yarn. Some were written in Flow, some in TypeScript. Every repo ran a different Node version.</p><p>Each repo worked fine on its own. The trouble started when you moved between them.</p><h3>10 repos, 10 ways of working</h3><p>Nothing was broken. Builds passed and features shipped. Each repo reflected when it was created and who worked on it at the time.</p><p>But picture a developer who works across several of them in the same week:</p><ul><li>Which package manager does this one use? Which Node version do I need? Why is the lockfile complaining?</li><li>The commands I typed from habit a minute ago don’t work here.</li><li>The test, build and CI setups all differ.</li></ul><p>Each issue is small, but they add up on every context switch.</p><h3>Developer experience is head space</h3><p>I think of developer experience as one question: how much of your head is left for the actual problem?</p><p>When the repo is a puzzle, the answer is “less than you’d like.” You spend the start of every task re-learning how this repo works before you can touch the business logic. No sprint report shows that cost, but the team pays it on every task.</p><p>New joiners feel it most. Instead of learning one way of working, they memorize ten and keep track of which repo follows which.</p><h3>Maintenance multiplied by N</h3><p>Every improvement also has to be made once per repo. A Node upgrade becomes N upgrades. A security patch becomes N patches, each with its own quirks. A CI improvement gets rewritten for N setups.</p><p>Work that costs N times as much often doesn’t get done, so the repos drift further apart.</p><h3>Picking the moment</h3><p>I didn’t start this on day one. Pushing standardization before you understand where the team hurts tends to fail. Once that was clear, we set one rule: one stack, the same in every repo.</p><p>The target stack:</p><ul><li>Language and runtime: TypeScript, React 19, Node 26, pnpm</li><li>Build and test: Vite, Vitest, Playwright</li><li>State and CI: Zustand, GitHub Actions</li></ul><p>I worked through the repos from most to least active. The busiest repos had the most people feeling the pain, so they got relief first and the payoff showed up where activity was highest.</p><h3>Where AI fit in</h3><p>Deciding what “standard” meant took longer than writing any of the migration code.</p><p>Once the stack was locked, the work was repetitive and well defined: move to pnpm, convert Flow to TypeScript, swap in Vite and Vitest, align GitHub Actions. AI handles that kind of refactoring well. With the target fixed, each repo took about 2–3 weeks with one developer.</p><p>A consolidation like this used to sit in the “someday” backlog because the cost never seemed worth it. With AI doing the repetitive parts, one developer could work through the whole list once the timing was right.</p><p>People decided the standard, and AI helped carry it out.</p><h3>What changed</h3><p>Developers move between repos with less friction: same package manager, build tool, test runner and CI shape. If you’ve written a test in one repo, you can write one in any of them. Nobody spends the first hour of a ticket figuring out how to run the repo locally. Dependency upgrades and security patches are now predictable and scriptable across all repos.</p><h3>Running a technical uplift in your team</h3><ol><li>Wait until you understand the friction points across the team.</li><li>Decide the stack before touching code. The decision is the hard part, and the rest is execution.</li><li>Start where the pain is highest, with the repos your team touches daily.</li><li>Keep the standard small and boring so nobody has to think about it.</li><li>Use AI for the repetitive middle, and keep architectural decisions with people.</li></ol><h3>Closing</h3><p>None of this is glamorous. Nobody ships a user-facing feature because lockfile formats match across repos. But every feature on our roadmap is now built by someone who didn’t have to relearn the codebase first.</p><p>How consistent are the repos where you work? Tell me what has worked, or failed, for your team in the comments.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fe0c35256217" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Do We Really Need the Most Advanced AI Models for Everyday Development?]]></title>
            <link>https://medium.com/@sabrinamsh/do-we-really-need-the-most-advanced-ai-models-for-everyday-development-6ef76b31880a?source=rss-15ffbc76f40e------2</link>
            <guid isPermaLink="false">https://medium.com/p/6ef76b31880a</guid>
            <category><![CDATA[harness-engineering]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[ai-model]]></category>
            <category><![CDATA[cost-control]]></category>
            <dc:creator><![CDATA[Sabrina Miao]]></dc:creator>
            <pubDate>Tue, 16 Jun 2026 18:18:55 GMT</pubDate>
            <atom:updated>2026-06-16T18:18:55.563Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*by3CeIthI3dqG9M1x8Bjhg.png" /></figure><p>Every time a new AI model is released, the conversation follows a familiar pattern.</p><p>People compare benchmarks. They debate reasoning capabilities. They celebrate coding scores and context window sizes. We all get excited about what the latest model can do.</p><p>I get excited too.</p><p>But recently I started asking myself a different question:</p><p><strong>Do I actually need the most advanced model for my day-to-day work?</strong></p><h3>My Default Choice</h3><p>For a long time, Sonnet has been my primary coding assistant.</p><p>Even after newer and more capable models were released, I continued using Sonnet because it consistently delivered strong results for software development tasks.</p><p>Recently, while working on a code refactoring task, I became curious.</p><p>Instead of automatically using my usual model, I decided to compare it with a smaller and cheaper alternative.</p><h3>A Simple Experiment</h3><p>The setup was straightforward.</p><p>I gave both models the same file and the same task: refactor the code.</p><p>The results were interesting.</p><ul><li>Sonnet consumed <strong>76.1 credits</strong></li><li>Haiku consumed <strong>13.3 credits</strong></li></ul><p>That’s approximately <strong>5.7× cheaper</strong>.</p><p>Naturally, I expected the more expensive model to produce the better result.</p><p>But that’s not what happened.</p><h3>The Output That Surprised Me</h3><p>To be completely honest, I preferred the solution from Haiku.</p><p>Instead of making incremental changes to the existing file, it split the code into three smaller files. The structure felt cleaner and easier to maintain.</p><p>What surprised me even more was that it followed the coding standards defined in our Copilot instructions more consistently.</p><p>The output wasn’t perfect.</p><p>Neither was Sonnet’s.</p><p>But when I compared the final results, I found myself preferring the work produced by the model that cost nearly six times less.</p><p>That forced me to rethink an assumption many of us make:</p><p><strong>Bigger and more expensive doesn’t automatically mean better.</strong></p><h3>The Harness Matters More Than We Think</h3><p>This experiment also reinforced something I’ve been learning over the past year.</p><p>Model capability is only one part of the equation.</p><p>In our repositories, we’ve spent considerable effort building what I call an AI development harness.</p><p>Instead of treating AI as a chatbot that magically understands our codebase, we provide it with a structured environment:</p><ul><li>Repository-specific instructions</li><li>Coding standards and conventions</li><li>Architectural guidance</li><li>Development workflows</li><li>Context about how the project is organized</li><li>Review and validation expectations</li></ul><p>I wrote about this approach in a previous article:</p><p><a href="https://medium.com/@sabrinamsh/beyond-coding-how-i-built-an-ai-harness-to-automate-my-development-lifecycle-77ea5e1788de"><em>Beyond Coding: How I Built an AI Harness to Automate My Development Lifecycle</em></a></p><p>What I’ve discovered is that once these guardrails are in place, smaller models become far more capable than many people expect.</p><p>The model is no longer trying to guess what “good” looks like.</p><p>The repository already tells it.</p><p>The architecture already guides it.</p><p>The instructions already define expectations.</p><p>In many ways, the AI harness becomes a force multiplier.</p><h3>Maybe We Are Optimizing the Wrong Thing</h3><p>When teams experience inconsistent AI results, the first reaction is often:</p><p>“Let’s use a bigger model.”</p><p>Sometimes that’s absolutely the right decision.</p><p>But I increasingly wonder whether we are overlooking a more important question:</p><p><strong>Have we created the right environment for the model to succeed?</strong></p><p>Because in this experiment, the smaller model wasn’t operating in isolation.</p><p>It had access to repository instructions.</p><p>It had coding standards.</p><p>It had architectural guidance.</p><p>It had context.</p><p>And it produced a solution that I preferred.</p><p>That suggests the quality of the harness may matter more than many benchmark discussions acknowledge.</p><h3>Prompt Quality Still Matters</h3><p>Another lesson from this experiment is that task clarity remains incredibly important.</p><p>A well-described task can significantly reduce the gap between a flagship model and a smaller model.</p><p>When requirements are clear, constraints are documented, and coding standards are explicit, smaller models often perform remarkably well.</p><p>Most day-to-day software engineering tasks are not cutting-edge research problems.</p><p>They’re things like:</p><ul><li>Refactoring code</li><li>Writing tests</li><li>Creating documentation</li><li>Implementing known patterns</li><li>Following established coding standards</li><li>Breaking large files into maintainable components</li></ul><p>For these types of tasks, a smaller model may be more than capable.</p><h3>Optimizing for Outcomes Instead of Benchmarks</h3><p>The AI industry naturally focuses on intelligence.</p><p>Every new release is measured against the previous generation.</p><p>And that’s important. Progress matters.</p><p>But in production environments, the question isn’t:</p><p>“Which model scored highest on a benchmark?”</p><p>The question is:</p><ul><li>Did the task get completed?</li><li>Was the result maintainable?</li><li>Did it follow project standards?</li><li>Was the cost justified?</li><li>Can the team scale its usage economically?</li></ul><p>Sometimes the answer will be to use the most advanced model available.</p><p>But increasingly, I’m finding that the better answer is:</p><p><strong>Use the least expensive model that can reliably solve the problem.</strong></p><h3>Final Thoughts</h3><p>I’m still excited every time a new model is released.</p><p>I’ll continue testing the latest and greatest systems.</p><p>But this small experiment reminded me of something important.</p><p>The goal isn’t to use the smartest model.</p><p>The goal is to get the best outcome.</p><p>And sometimes the difference between success and failure isn’t the model at all.</p><p>It’s the harness around it.</p><p>The AI industry spends a lot of time discussing model intelligence.</p><p>I think we should spend more time discussing harness quality.</p><p>Because once the guardrails, standards, and context are in place, a model that’s <strong>5.7× cheaper</strong> can sometimes deliver results that are just as good — or even better.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6ef76b31880a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Hidden ROI of AI Refactoring: Why Big-Bang Legacy Upgrades Fail]]></title>
            <link>https://medium.com/@sabrinamsh/the-hidden-roi-of-ai-refactoring-why-big-bang-legacy-upgrades-fail-b935896bffda?source=rss-15ffbc76f40e------2</link>
            <guid isPermaLink="false">https://medium.com/p/b935896bffda</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Sabrina Miao]]></dc:creator>
            <pubDate>Fri, 12 Jun 2026 15:56:48 GMT</pubDate>
            <atom:updated>2026-06-17T09:02:15.459Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EembdZP2z8Mv7MZMMVNZvQ.png" /></figure><p>Our legacy repository had quietly become a liability</p><p>Security vulnerabilities were stacking up. Maintenance costs kept growing. Every hour spent maintaining the system was an hour not spent delivering customer value.</p><p>The biggest problem wasn’t technical debt itself — it was developer avoidance.</p><p>The tooling was so outdated that engineers actively dreaded working on the codebase. Simple changes took longer than they should. New contributors faced a steep learning curve. Before we could build anything meaningful, we needed to modernize the stack.</p><p>Like many engineering leaders experimenting with AI-assisted development, I thought I had found a shortcut.</p><p>I decided to attempt a “big-bang” modernization. Feed the codebase into an LLM, describe the target state, and let the model upgrade everything in one pass.</p><p>Three days later, I abandoned the effort.</p><p>The model wasn’t just making mistakes — it was creating new ones faster than I could fix them. Dependencies broke. Configuration files drifted out of sync. APIs were upgraded in one place and forgotten in another. Every generation looked plausible on the surface, but the build became increasingly unstable.</p><p>I spent hours untangling issues that hadn’t existed before.</p><p>That’s when I realized something important:</p><p>I wasn’t dealing with a coding problem.</p><p>I was dealing with a systems problem.</p><p>And I had made the mistake of treating a distributed system like a prompt.</p><h3>The Real Cost of Large Context Windows</h3><p>The common narrative around AI is that more context produces better results.</p><p>In practice, that’s only partially true.</p><p>A modern enterprise application isn’t a collection of independent files. It’s a network of interconnected dependencies, configurations, frameworks, APIs, and implicit architectural decisions accumulated over years.</p><p>When you dump an entire codebase into a large context window and ask an LLM to “modernize the project,” you’re asking it to reason about a highly interconnected system all at once.</p><p>The failure mode is subtle.</p><p>The model often produces changes that are locally correct but globally wrong.</p><p>A package upgrade may be valid in one module while silently breaking another. A deprecated API may be replaced correctly in one area while introducing compatibility issues elsewhere. Configuration migrations may appear successful until downstream services begin failing.</p><p>The larger the dependency graph inside the prompt, the larger the surface area for these failures.</p><p>And when the model loses track of relationships, hallucinations become expensive.</p><p>You pay once in tokens to provide massive amounts of context.</p><p>Then you pay again in engineering time to debug the resulting issues.</p><p>The economics are brutal.</p><h3>Understanding Blast Radius</h3><p>Every experienced architect understands blast radius.</p><p>You don’t deploy a risky change across an entire platform at once. You isolate it. You constrain it. You validate it before expanding outward.</p><p>Yet this is exactly how many teams approach AI-assisted refactoring.</p><p>They hand the model years of accumulated technical debt, dozens of dependencies, multiple frameworks, and hundreds of interconnected files — and then ask for a complete modernization.</p><p>The blast radius becomes the entire application.</p><p>The issue isn’t that AI lacks capability.</p><p>The issue is that we’ve removed the boundaries that allow it to succeed.</p><p>AI performs best when operating within clearly defined constraints. The more ambiguity and interconnected complexity you introduce, the more unpredictable the output becomes.</p><p>This isn’t an AI limitation as much as it is a systems design reality.</p><p>Complex systems require decomposition.</p><p>That principle doesn’t disappear because an LLM is involved.</p><h3>The Shift That Changed Everything</h3><p>After three frustrating days, I stopped prompting and started planning.</p><p>Instead of asking the model to modernize the application, I stepped back and mapped the upgrade path.</p><p>I documented:</p><ul><li>Framework upgrade dependencies</li><li>Package compatibility requirements</li><li>Breaking changes between versions</li><li>Migration sequencing</li><li>Potential risk areas</li></ul><p>Then I broke the modernization effort into a series of tightly scoped stories.</p><p>Rather than saying:</p><p>“Upgrade the entire application.”</p><p>I started saying:</p><ul><li>Upgrade package X from version A to version B.</li><li>Resolve these specific deprecation warnings.</li><li>Migrate this configuration file.</li><li>Refactor this isolated module to support the new API.</li><li>Update these tests and validate the build.</li></ul><p>Each task had a clear objective, limited context, and an obvious definition of done.</p><p>The AI wasn’t acting as an architect anymore.</p><p>It was acting as an execution engine.</p><h3>Sequential Slicing Beats Heroic Prompts</h3><p>The difference was immediate.</p><p>Outputs became more predictable.</p><p>Build failures dropped dramatically.</p><p>Dependency issues became easier to identify and fix.</p><p>Most importantly, progress became measurable.</p><p>Instead of reviewing hundreds of risky changes generated in a single pass, I reviewed small batches of targeted modifications that could be validated independently.</p><p>Every completed story reduced technical debt without introducing unnecessary risk.</p><p>The modernization effort began to resemble a normal engineering project rather than an AI experiment.</p><p>And that’s when the hidden ROI appeared.</p><h3>The Hidden ROI of AI Refactoring</h3><p>Most discussions about AI focus on speed.</p><p>The real value is predictability.</p><p>When modernization work is decomposed into small, isolated units:</p><ul><li>Token consumption drops.</li><li>Context resets become smaller.</li><li>Hallucinations decrease.</li><li>Validation becomes faster.</li><li>Regression risk falls dramatically.</li><li>Engineering confidence increases.</li></ul><p>The gains compound.</p><p>Instead of repeatedly paying for large prompts and expensive debugging cycles, you’re executing a series of low-risk improvements with high confidence.</p><p>The result isn’t just faster delivery.</p><p>It’s more reliable delivery.</p><p>And in most engineering organizations, reliability is where the real ROI lives.</p><h3>Architecture Still Matters</h3><p>AI is an extraordinary tool for reducing technical debt.</p><p>It can accelerate migrations, automate repetitive refactoring, and help teams modernize legacy systems significantly faster than traditional approaches.</p><p>But it doesn’t eliminate the need for architectural thinking.</p><p>In many ways, it makes architecture even more important.</p><p>The organizations seeing the highest returns from AI aren’t using larger prompts.</p><p>They’re using better decomposition.</p><p>They map dependencies before generating code.</p><p>They reduce blast radius before introducing change.</p><p>They define boundaries before asking AI to execute.</p><p>AI is exceptional at solving well-defined problems.</p><p>Architecture is deciding what those problems should be.</p><p>If your next modernization effort feels too large for humans to tackle efficiently, don’t hand the entire system to an LLM and hope for the best.</p><p>Map the dependencies.</p><p>Slice the work into small stories.</p><p>Constrain the blast radius.</p><p>Then let AI do what it does best.</p><p>The biggest lesson I learned wasn’t how to write better prompts.</p><p>It was that the highest ROI from AI comes from applying timeless engineering principles before the first prompt is ever written.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b935896bffda" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Beyond Prompt Engineering: Why Production AI Needs Feedback Loops, Not Better Prompts]]></title>
            <link>https://medium.com/@sabrinamsh/beyond-prompt-engineering-why-production-ai-needs-feedback-loops-not-better-prompts-7052b566ba8b?source=rss-15ffbc76f40e------2</link>
            <guid isPermaLink="false">https://medium.com/p/7052b566ba8b</guid>
            <category><![CDATA[agentic-ai]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[loop-engineering]]></category>
            <dc:creator><![CDATA[Sabrina Miao]]></dc:creator>
            <pubDate>Thu, 11 Jun 2026 21:42:13 GMT</pubDate>
            <atom:updated>2026-06-13T18:13:49.333Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*P5LUzcQfLPyAFZkUFAkj-Q.png" /></figure><p>For the past year, I’ve been obsessed with one question:</p><p><strong>How do we move AI from a clever novelty to a reliable workhorse?</strong></p><p>When I first started working with large language models, it felt like alchemy. We’d spend hours refining prompts, adjusting system instructions, and experimenting with different approaches in the hope of getting more consistent results.</p><p>And often, it worked.</p><p>Prompt engineering taught me an important lesson: the quality of the instruction matters. A well-crafted prompt can dramatically improve outcomes.</p><p>But as I started building AI systems for real-world workflows, I found myself facing a different challenge. Even excellent prompts couldn’t solve problems like validation, recovery, reliability, and long-running tasks.</p><p>The limitation wasn’t prompt engineering itself.</p><p>The limitation was expecting prompts to solve problems that are fundamentally architectural.</p><p>That realization changed how I think about AI systems.</p><h3>The Four Stages of My AI Journey</h3><p>Looking back, my approach evolved through four distinct stages.</p><h3>1. Prompt Engineering: The Instruction Stage</h3><p>Like most developers, I started with prompts.</p><p>For many use cases, prompts are still the fastest and most effective way to improve results. They define intent, establish constraints, and guide the model’s behavior.</p><p>But every interaction remained largely independent. The model generated an answer, and the process ended there.</p><p>For simple tasks, that’s often enough.</p><p>For production systems, it rarely is.</p><h3>2. Context Engineering: The Knowledge Stage</h3><p>My next realization was that many AI failures weren’t caused by poor reasoning.</p><p>They were caused by missing information.</p><p>By introducing retrieval-augmented generation (RAG), I could provide the model with the right information at the right time. Responses became significantly more relevant because the model could work from current and domain-specific knowledge rather than relying solely on training data.</p><p>This was a major step forward.</p><p>But despite having better context, interactions were still largely one-shot experiences.</p><p>The model had more knowledge, but it still wasn’t learning from mistakes.</p><h3>3. Harness Engineering: The Capability Stage</h3><p>The next breakthrough came when I stopped treating prompts as the primary interface and started treating the model as one component inside a larger system.</p><p>Instead of simply generating answers, the model gained access to tools, APIs, repositories, scripts, and deployment workflows.</p><p>I wrote about this evolution in my article, <a href="https://medium.com/@sabrinamsh/beyond-coding-how-i-built-an-ai-harness-to-automate-my-development-lifecycle-77ea5e1788de"><em>Beyond Coding: How I Built an AI Harness to Automate My Development Lifecycle</em></a>.</p><p>This changed how I worked. The AI could now perform actions rather than merely discuss them.</p><p>Yet a familiar problem remained.</p><p>What happens when the AI fails?</p><h3>4. Loop Engineering: The Resilience Stage</h3><p>This is where my current thinking has landed.</p><p>The biggest shift wasn’t giving the model more information.</p><p>And it wasn’t giving the model more tools.</p><p>It was designing systems that could recover from mistakes.</p><p>Modern AI agents increasingly rely on iterative feedback loops. Whether they’re called agent loops, reflection loops, evaluation loops, or validation loops, they all follow a similar pattern:</p><ol><li>Generate a result.</li><li>Evaluate the result.</li><li>Capture feedback.</li><li>Try again.</li></ol><p>Instead of treating the first answer as final, the system treats it as a draft.</p><p>That single shift changes how we think about reliability.</p><h3>The Most Important Insight</h3><p>The biggest shift in my thinking was realizing that reliability doesn’t come from making the model smarter.</p><p>It comes from designing systems that can detect mistakes, learn from them, and try again.</p><p>For decades, software engineering has focused on handling failure gracefully. Distributed systems retry requests. CI pipelines catch defects. Monitoring systems detect anomalies.</p><p>AI systems should be designed with the same mindset.</p><p>The future of production AI isn’t about finding the perfect prompt.</p><p>It’s about building infrastructure that can handle imperfect outputs.</p><h3>From Prompt Engineers to Process Engineers</h3><p>Prompt engineering isn’t disappearing.</p><p>If anything, it’s becoming a foundational skill.</p><p>But it’s only one layer of a much larger stack.</p><p>As AI systems mature, our role is evolving beyond writing instructions for models. We’re designing validation layers, tool integrations, recovery paths, feedback mechanisms, and execution workflows.</p><p>We’re becoming engineers of processes rather than engineers of prompts.</p><p>Because the future of production-grade AI doesn’t depend on getting the first answer right.</p><p>It depends on what happens when the first answer is wrong.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7052b566ba8b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Beyond Coding: Why I Built an AI Harness to Automate My Development Lifecycle]]></title>
            <link>https://medium.com/@sabrinamsh/beyond-coding-how-i-built-an-ai-harness-to-automate-my-development-lifecycle-77ea5e1788de?source=rss-15ffbc76f40e------2</link>
            <guid isPermaLink="false">https://medium.com/p/77ea5e1788de</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[product-management]]></category>
            <category><![CDATA[productivity]]></category>
            <category><![CDATA[tech-leadership]]></category>
            <dc:creator><![CDATA[Sabrina Miao]]></dc:creator>
            <pubDate>Fri, 29 May 2026 16:15:26 GMT</pubDate>
            <atom:updated>2026-06-11T21:59:54.696Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/700/0*MHCZN36of6fDCLt6.png" /></figure><p>Most conversations about AI-assisted development focus on coding.</p><p>Which model writes the best code? Which IDE has the best autocomplete? Which agent can generate an entire application from a prompt?</p><p>After spending months experimenting with AI coding tools, I came to a different conclusion:</p><p>The bottleneck wasn’t coding.</p><p>The bottleneck was everything surrounding coding.</p><p>Planning, requirements analysis, architecture decisions, testing, code reviews, documentation, deployment preparation, and validation were still consuming most of my time. AI could generate code quickly, but turning that code into production-ready software remained a fragmented and highly manual process.</p><p>That’s when I stopped thinking about AI as a coding assistant and started thinking about it as part of a development system.</p><p>This led me to build an AI harness: a structured workflow that orchestrates AI across the entire development lifecycle rather than treating code generation as an isolated activity.</p><h3>The Problem with AI Coding Assistants</h3><p>Most AI development workflows look something like this:</p><ol><li>Write a prompt</li><li>Generate code</li><li>Review the output</li><li>Fix mistakes</li><li>Generate more code</li><li>Repeat</li></ol><p>This approach works surprisingly well for small tasks.</p><p>However, as projects grow, several problems emerge:</p><ul><li>Requirements become unclear</li><li>Context gets lost</li><li>Architecture drifts over time</li><li>Tests become inconsistent</li><li>Documentation falls behind</li><li>Code quality varies between sessions</li></ul><p>The result is often faster coding but not necessarily faster software delivery.</p><p>I found myself spending significant time managing the AI rather than building software.</p><h3>The Insight: Build a System, Not a Prompt</h3><p>The breakthrough came when I stopped optimizing prompts and started optimizing the process.</p><p>Instead of asking:</p><p>“How can I get AI to write better code?”</p><p>I asked:</p><p>“How can I create a workflow that consistently produces high-quality software regardless of which AI model is being used?”</p><p>The answer was a harness that coordinates multiple development activities and enforces structure throughout the lifecycle.</p><h3>What the AI Harness Does</h3><p>At a high level, the workflow looks like this:</p><p>Feature Request<br>↓<br>Requirements Analysis<br>↓<br>Implementation Planning<br>↓<br>Code Generation<br>↓<br>Test Generation<br>↓<br>Validation<br>↓<br>Documentation<br>↓<br>Review &amp; Approval</p><p>Each stage produces artifacts that become inputs to the next stage.</p><p>Rather than relying on a single massive prompt, the system breaks development into smaller, specialized steps.</p><p>This reduces context overload and improves consistency.</p><h3>A Real Example</h3><p>Imagine receiving the following feature request:</p><p>“Add support for energy price forecasting to the application.”</p><p>The harness does not immediately generate code.</p><p>Instead, it:</p><h3>Step 1: Analyze Requirements</h3><p>The system identifies:</p><ul><li>Business objectives</li><li>Functional requirements</li><li>Technical dependencies</li><li>Potential edge cases</li></ul><h3>Step 2: Generate an Implementation Plan</h3><p>Before coding begins, the harness produces:</p><ul><li>Architecture updates</li><li>Required services</li><li>Database changes</li><li>API integrations</li><li>Testing strategy</li></ul><h3>Step 3: Generate Code</h3><p>Only after planning is complete does implementation begin.</p><p>Because the AI is working from a structured specification rather than a vague prompt, the generated code is significantly more aligned with project requirements.</p><h3>Step 4: Generate Tests</h3><p>The harness automatically creates:</p><ul><li>Unit tests</li><li>Integration tests</li><li>Validation scenarios</li></ul><h3>Step 5: Produce Documentation</h3><p>Technical documentation and implementation notes are generated alongside the code rather than being treated as an afterthought.</p><h3>What Worked Better Than Expected</h3><p>Several benefits emerged that I wasn’t initially optimizing for.</p><h3>Consistency</h3><p>The biggest improvement wasn’t speed.</p><p>It was predictability.</p><p>The system produces outputs that follow the same standards regardless of task complexity.</p><h3>Reduced Context Switching</h3><p>Instead of constantly deciding what to do next, the workflow itself drives execution.</p><p>This allows me to focus on higher-level decisions.</p><h3>Better Knowledge Capture</h3><p>Every stage creates artifacts that document reasoning, decisions, and implementation details.</p><p>The project becomes easier to understand over time rather than harder.</p><h3>What Still Goes Wrong</h3><p>The system is far from perfect.</p><p>AI still:</p><ul><li>Misinterprets requirements</li><li>Makes architectural assumptions</li><li>Generates overly complex solutions</li><li>Misses edge cases</li><li>Produces tests that pass without validating the right behavior</li></ul><p>This is why human review remains essential.</p><p>The goal is not autonomous development.</p><p>The goal is amplifying developer effectiveness while maintaining engineering discipline.</p><h3>Lessons Learned</h3><p>If I were starting again today, I would:</p><ol><li>Invest more heavily in specifications.</li><li>Add evaluation and validation earlier.</li><li>Reduce unnecessary agent complexity.</li><li>Improve observability across the workflow.</li><li>Focus on process design before model selection.</li></ol><p>Ironically, model choice became less important as the harness matured.</p><p>A well-structured process often produced better results than simply switching to a more capable model.</p><h3>The Bigger Opportunity</h3><p>I believe the future of AI-assisted software development is not about replacing developers.</p><p>It is about building systems that automate the repetitive coordination work surrounding software development.</p><p>Coding is only one step in the lifecycle.</p><p>Planning, testing, validation, documentation, and review are equally important.</p><p>Organizations that treat AI as a development platform rather than a code generator will likely see the greatest long-term gains.</p><p>The most valuable engineering skill may no longer be writing code faster.</p><p>It may be designing workflows that allow humans and AI to work together effectively.</p><p>That’s the real purpose of the AI harness I built.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=77ea5e1788de" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>