<?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 Duraid Wadie on Medium]]></title>
        <description><![CDATA[Stories by Duraid Wadie on Medium]]></description>
        <link>https://medium.com/@duraidw?source=rss-aa10e04bba51------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*t1S7nSJiDWHfsndl1jKzWw.png</url>
            <title>Stories by Duraid Wadie on Medium</title>
            <link>https://medium.com/@duraidw?source=rss-aa10e04bba51------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 14:27:43 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@duraidw/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[AI Changed the Cyber Risk Clock. M&A Due Diligence Has to Catch Up.]]></title>
            <link>https://medium.com/@duraidw/ai-changed-the-cyber-risk-clock-m-a-due-diligence-has-to-catch-up-b68b8901acb7?source=rss-aa10e04bba51------2</link>
            <guid isPermaLink="false">https://medium.com/p/b68b8901acb7</guid>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[cyber-security-awareness]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[application-security]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <dc:creator><![CDATA[Duraid Wadie]]></dc:creator>
            <pubDate>Sat, 29 Aug 2026 09:59:28 GMT</pubDate>
            <atom:updated>2026-08-29T09:59:28.096Z</atom:updated>
            <content:encoded><![CDATA[<p>AI is compressing the time between vulnerability and exploitation. In an acquisition, that changes what buyers need to know before they buy.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*d6FCZB7TI2L_VRcoYpS_6A.jpeg" /><figcaption>Designed by Freepik</figcaption></figure><h3>What you’ll take away</h3><p>· Why cyber risk is now part of acquisition value, not just a technical checklist</p><p>· Why application security deserves more attention in M&amp;A</p><p>· How AI can compress the window between vulnerability and exploitation</p><p>· Why integration creates a second cyber-risk window</p><p>· What buyers should ask before closing a technology-heavy deal</p><h3>The question is changing</h3><p>A target looks healthy. Revenue is growing. The product works. The security questionnaire comes back without a major red flag.</p><p>Then the buyer discovers an internet-facing application with a recently disclosed vulnerability. A fix exists. It has not been deployed everywhere.</p><p>The old question was:</p><p>“How vulnerable is the company?”</p><p>The more important question is becoming:</p><p>“How quickly could this weakness become an incident?”</p><h3>A security questionnaire is only part of the picture</h3><p>Traditional diligence still matters: breaches, security controls, identity, incident response, regulations, insurance and vulnerability management.</p><p>But those questions describe a company at a point in time.</p><p>The threat environment is moving faster.</p><p>Rapid7 reported that high- and critical-severity vulnerabilities actively exploited in the wild more than doubled from 2024 to 2025, while exploitation timelines continued to shrink. Fortinet and Sophos have also described attackers using AI and automation to compress parts of the attack lifecycle.</p><p>The important change is simple:</p><p>The clock is getting shorter.</p><h3>The application is part of what you are buying</h3><p>Two targets can have similar revenue, similar security policies and similar questionnaire answers.</p><p>But one may have a small, well-understood external footprint. The other may have hundreds of APIs, old domains, legacy applications, inconsistent patching and limited visibility.</p><p>Those companies do not carry the same technology risk.</p><p>You are not buying the questionnaire. You are buying what sits behind it.</p><p>The buyer is acquiring the applications, infrastructure, dependencies and exposure behind it.</p><h3>The clock is getting shorter</h3><p>AI does not need to invent a completely new attack to change the risk.</p><p>It can make familiar work faster: finding weaknesses, analysing targets, generating code and supporting parts of an intrusion.</p><p>Current security research increasingly describes AI as a force that compresses attack timelines.</p><p>That means a vulnerability does not have to be catastrophic to matter.</p><p>It has to be exposed, reachable, valuable enough to target and exploitable quickly enough.</p><h3>The deal itself creates another window of risk</h3><p>The acquisition itself can create temporary weaknesses.</p><p>Credentials change. Networks connect. Identity systems are integrated. Applications move. Security tools are consolidated. Temporary exceptions appear.</p><p>The buyer may have a mature security organisation while the target has a completely different security model.</p><p>For a period, the combined company can have the weaknesses of both without yet having the strengths of either.</p><p>So buyers need to ask two questions:</p><p>What risk are we buying?</p><p>What new risk will the act of buying create?</p><h3>Five questions I would want answered</h3><p><strong>What is actually exposed?</strong></p><p>Map the real external attack surface, including forgotten applications, domains, APIs and cloud assets.</p><p><strong>Which applications matter to the deal thesis?</strong></p><p>A weakness in a critical revenue system matters differently from one in an isolated internal tool.</p><p><strong>How quickly can the target detect and remediate?</strong></p><p>Look beyond the vulnerability backlog. Understand visibility, ownership and response speed.</p><p><strong>What happens when the companies connect?</strong></p><p>Review identity, network, API, cloud and data dependencies before integration.</p><p><strong>What will remediation cost?</strong></p><p>Translate security findings into engineering cost, integration work, timing and potential deal impact.</p><h3>Put the security cost into the deal model</h3><p>If the target needs major application remediation, identity redesign, legacy replacement, additional security staff or accelerated monitoring, those are not abstract security problems.</p><p>They are costs.</p><p>They can affect purchase price, deal terms, escrow, warranties, pre-close remediation and the integration budget.</p><p>The useful question is not:</p><p>“Does the target have cyber risk?”</p><p>Every target has risk.</p><p>The useful question is:</p><p>“How much of our post-acquisition security and engineering capacity will this risk consume?”</p><h3>There is another question when AI helped build the software</h3><p>There is one more question emerging as AI-assisted development becomes common:</p><p>How much of the target’s software was generated or modified with AI, and how is that software governed?</p><p>Who reviews it? How are dependencies and secrets controlled? Can engineers explain the important security assumptions? Which AI tools have access to source code or sensitive data?</p><p>These are not arguments against AI-assisted development.</p><p>They are questions about how the software was produced, understood and secured.</p><h3>What good diligence looks like now</h3><p>The best buyers will not ask only:</p><p>“Is this company secure?”</p><p>They will ask:</p><p>“What can be attacked, how quickly could it matter, how quickly can we detect it, what will it cost to fix, and what happens when we connect this company to ours?”</p><p>A deal has its own timetable.</p><p>Attackers can operate on a very different timetable.</p><p>Those clocks are no longer comfortably aligned.</p><p><strong>Cybersecurity should not sit at the end of the technology checklist.</strong></p><p>It belongs inside the investment thesis.</p><h3>A question for the deal team</h3><p>When was the last time your M&amp;A cyber diligence tested the target’s actual external exposure, rather than only reviewing its security documentation?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b68b8901acb7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[When Architecture Becomes Theatre]]></title>
            <link>https://medium.com/@duraidw/when-architecture-becomes-theatre-5d1d96a49890?source=rss-aa10e04bba51------2</link>
            <guid isPermaLink="false">https://medium.com/p/5d1d96a49890</guid>
            <category><![CDATA[systems-thinking]]></category>
            <category><![CDATA[enterprise-architecture]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-architecture]]></category>
            <dc:creator><![CDATA[Duraid Wadie]]></dc:creator>
            <pubDate>Sat, 29 Aug 2026 09:31:22 GMT</pubDate>
            <atom:updated>2026-08-29T09:31:22.177Z</atom:updated>
            <content:encoded><![CDATA[<p><em>When the decision is already made, are architects designing a solution or simply explaining one?</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Uhrsp7UI78SQyXqM-_4s_w.png" /><figcaption>Designed by Freepik</figcaption></figure><p><strong>What you’ll take away</strong></p><p>How to tell when an architecture decision is genuinely open</p><p>Why trade-offs matter more than technology preferences</p><p>How organisational politics can turn architecture into justification</p><p>Why AI makes this problem more important, not less</p><p>What architects and leaders can do to make decisions more honest</p><p><strong>The decision may already be made</strong></p><p>Sometimes an architecture meeting begins with:</p><p>“What should we build?”</p><p>But the answer has already been chosen.</p><p>The vendor is selected. The platform is promised. The migration is announced. The budget is approved.</p><p>Then the architects are invited in.</p><p>Not to explore the solution space. Not to compare alternatives. Not to challenge the premise.</p><p>They are asked to make the decision work.</p><p>That is when architecture can become theatre.</p><p><strong>Architecture starts with uncertainty</strong></p><p>Good architecture begins before the answer is obvious.</p><p>What problem are we solving?</p><p>What constraints are real?</p><p>What alternatives exist?</p><p>What are we trading away?</p><p>What would make us change our mind?</p><p>Only then should the team choose.</p><p><strong>The healthy process is:</strong></p><p>Explore → compare → decide → explain</p><p><strong>The unhealthy version is:</strong></p><p>Decide → justify → document</p><p>Both can produce beautiful diagrams. Only one is really exploring architecture.</p><p><strong>Architecture is the trade-off, not the diagram</strong></p><p>Suppose an agent or engineering team proposes three services instead of one.</p><p>The design looks clean. Responsibilities are separated. Scaling can be independent.</p><p>But now there are more deployments, network calls, monitoring, failure modes and ownership boundaries.</p><p>Maybe three services are worth it. Maybe the simpler design is better.</p><p>The architecture is not the diagram showing three boxes.</p><p>The architecture is the decision about whether the extra complexity is worth the benefit.</p><p><strong>The most dangerous sentence: “We’ve already decided.”</strong></p><p>Sometimes a decision really is constrained.</p><p>A regulation may require it. A customer contract may require it. A security policy may remove alternatives.</p><p>That is not bad architecture. Constraints are part of architecture.</p><p>The problem is pretending the decision is open when it is not.</p><p>If a vendor has already been selected, say so. Then architects can focus on the decisions that remain.</p><p>Honest constraints are far better than fake choice.</p><p><strong>Politics is part of architecture. Pretending it isn’t is the problem.</strong></p><p>Large technology decisions involve budgets, deadlines, strategy, people and power.</p><p>That is normal.</p><p>The problem begins when a political decision is presented as a purely technical conclusion.</p><p>“We chose this because it is technically superior” sounds very different from “The organisation already committed to this vendor, so we evaluated the best way to use it.”</p><p>The second statement may be less elegant. It is also more useful.</p><p><strong>Architects need permission to say no</strong></p><p>An architect who can only make a chosen solution work is providing implementation support, not independent architectural judgement.</p><p>Sometimes the most valuable architectural answer is:</p><p>“We could build this. But we should not.”</p><p>Or:</p><p>“This option works, but here is the cost you are accepting.”</p><p>Or simply:</p><p>“Before we choose the technology, we need to challenge the assumption behind the requirement.”</p><p>That is not obstruction.</p><p>That is architecture.</p><p><strong>AI makes the problem bigger</strong></p><p>AI coding agents can now turn architectural choices into working software extremely quickly.</p><p>Choose a framework. Create a service. Generate the APIs. Create the schema. Add authentication. Write the tests.</p><p>The implementation loop gets shorter.</p><p>That creates a new risk.</p><p>A questionable architectural decision can spread through a codebase before anyone stops to ask whether the decision itself was sound.</p><p>The question is no longer only:</p><p>“Did we choose the wrong architecture?”</p><p>It becomes:</p><p>“How much software did we build before we realised it?”</p><p><strong>The architect’s job is not to predict the future</strong></p><p>No architect can guarantee that today’s decision will be right forever.</p><p>The goal is not perfect prediction.</p><p>It is deliberate choice.</p><p>Understand the alternatives. Make the constraints visible. Expose the trade-offs. Record why the decision was made. Know what would cause you to revisit it.</p><p>Good architecture is not certainty.</p><p>It is disciplined uncertainty.</p><p><strong>Five questions that cut through the theatre</strong></p><p><strong>What problem are we actually solving?</strong></p><p>If the problem is unclear, the architecture is premature.</p><p><strong>What alternatives did we consider?</strong></p><p>If there are no alternatives, you may be documenting a preference rather than making a decision.</p><p><strong>What are we giving up?</strong></p><p>Every architecture choice has a cost.</p><p><strong>What would make us change our mind?</strong></p><p>A decision without a revisit condition can quietly become dogma.</p><p><strong>Who owns the consequences?</strong></p><p>The diagram will be forgotten. The consequences will not.</p><p><strong>The best architects create better decisions</strong></p><p>The strongest architects are not the people with the strongest technology opinions.</p><p>They make the organisation think better.</p><p>They create space for alternatives. They expose assumptions. They make trade-offs visible. They know when complexity is justified and when the boring solution is the better one.</p><p>They do not need to win every argument.</p><p>They need the organisation to understand what it is choosing.</p><p><strong>Architecture begins with an honest question</strong></p><p>Before asking, “Which architecture should we choose?” ask:</p><p>“Is the decision actually open?”</p><p>If it is open, explore it.</p><p>If it is constrained, make the constraints explicit.</p><p>If it is already decided, do not pretend architecture produced the decision.</p><p><strong>Architecture is not the art of making a predetermined answer look inevitable.</strong></p><p><strong>It is the discipline of exploring what could be, understanding the trade-offs, and consciously choosing what should be.</strong></p><p>And sometimes the most valuable thing an architect can do is not design the solution.</p><p><strong>It is to stop the organisation from designing the wrong one.</strong></p><p><strong>A question for architects, developers and leaders</strong></p><p>Have you ever been asked to provide an architecture for a decision that was already made?</p><p>When should an architect challenge the premise instead of designing the solution?</p><p>As AI makes implementation faster, should architectural review become more important?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5d1d96a49890" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AI Writes the Code. Do Developers Become Architects?]]></title>
            <link>https://medium.com/@duraidw/ai-writes-the-code-do-developers-become-architects-c3ec2a098fb9?source=rss-aa10e04bba51------2</link>
            <guid isPermaLink="false">https://medium.com/p/c3ec2a098fb9</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[claude-code]]></category>
            <category><![CDATA[software-architecture]]></category>
            <dc:creator><![CDATA[Duraid Wadie]]></dc:creator>
            <pubDate>Sun, 23 Aug 2026 07:08:41 GMT</pubDate>
            <atom:updated>2026-08-23T07:08:41.120Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UQCA4FgG0UPAdJdF452fVg.jpeg" /><figcaption>Designed by Freepik</figcaption></figure><h3>What you’ll take away</h3><p>· Why AI writing more code does not automatically make developers architects</p><p>· Why architecture is really about trade-offs and system-level consequences</p><p>· Why architects remain important as coding agents become more capable</p><p>· What developers can miss when they move too far away from implementation</p><p>· How the developer’s role can shift from writing every line to owning more of the decisions around the code</p><h3>AI writes the code. So what happens to the developer?</h3><p>Today you can give an AI agent a feature request.</p><p>It reads the repository. It chooses an approach. It writes the code. It runs the tests. It fixes failures. It opens a pull request.</p><p>You review it or even another agent does the review.</p><p>So what exactly is the developer’s job now?</p><p>That question is more interesting than whether AI can write code. It can.</p><p>The harder question is where engineering judgement moves when implementation becomes cheaper.</p><h3>Does that make developers architects?</h3><p>Not automatically.</p><p>Writing less code does not make someone an architect.</p><p>Architecture is the discipline of making consequential choices under constraints: where system boundaries belong, where data should live, what happens when dependencies fail, how much complexity a team can operate, and which trade-offs the organisation is willing to accept.</p><p>AI can help with those decisions. It can also make them implicitly while implementing a task.</p><p>If an agent chooses a framework, database, service boundary or deployment pattern, someone still has to decide whether that choice is right for the whole system.</p><h3>Architecture is the trade-off, not the diagram</h3><p>Suppose an agent proposes splitting a new capability into three services.</p><p>The design looks clean. Each service has a clear responsibility.</p><p>But now there are three deployments, more network calls, more monitoring, more failure modes and more ownership boundaries.</p><p>Maybe three services are the right answer. Maybe one service is better.</p><p>The agent can produce either design.</p><p>The architectural decision is deciding which cost the organisation is willing to live with.</p><p>Architecture is not simply producing a good diagram. It is making a decision whose consequences extend beyond the task in front of you.</p><h3>AI makes architects more important, not less</h3><p>AI can optimise the task in front of it. Architects have to optimise the system around it.</p><p>An agent may choose a database that works well for a new feature. An architect has to consider how that choice affects operations, security, cost, data ownership and future migrations.</p><p>An agent may create another service because the requirement suggests separation. An architect has to ask whether the organisation can afford another service to operate.</p><p>An agent can propose an elegant abstraction. An architect has to decide whether that abstraction will still make sense when the system, team and requirements change.</p><p>The faster agents can turn decisions into working software, the more important it becomes to make the right decisions before those choices spread through the system.</p><h3>If developers become architects, what might they miss?</h3><p>There is an uncomfortable side to the idea that AI will turn developers into architects.</p><p>Writing less code can create distance from the system.</p><p>When you implement a design yourself, you encounter its friction. You discover that the abstraction is awkward. The API does not behave as expected. The database model creates unexpected queries. The elegant design on the whiteboard becomes surprisingly difficult to operate.</p><p>Those problems are valuable information.</p><p>An AI agent can hide some of that friction by simply fixing the implementation.</p><p>That creates a risk: a developer may approve a design without experiencing enough of its consequences.</p><p>The things that can become easier to miss include:</p><p>· Operational reality: a design still has to be deployed, monitored, backed up and recovered.</p><p>· Performance: a system can pass tests and still behave badly under real traffic.</p><p>· Failure modes: distributed systems can fail in ways that are hard to see from a diagram.</p><p>· Maintainability: an elegant abstraction can make the next change harder.</p><p>· Team capability: a technically sound architecture can still be too complex for the team that operates it.</p><p>· Historical context: an apparently strange design may exist because of an old incident, migration or constraint.</p><p>The implementation is part of the feedback loop.</p><p>AI should reduce unnecessary typing, not remove the developer’s contact with reality.</p><h3>The developer’s new job</h3><p>The future is not simply ‘developers become architects.’</p><p>It is a shift in where developers spend their attention.</p><p>The job increasingly looks like this:</p><p>· Understand the problem.</p><p>· Question the assumptions.</p><p>· Decide the trade-offs.</p><p>· Delegate the implementation.</p><p>· Verify the result.</p><p>A senior developer working with agents may write fewer lines while making more consequential decisions.</p><p>They decide which requirements are ambiguous before the agent starts. They recognise when a generated abstraction is unnecessary. They know when a simple design is better than another distributed component. They know when the team’s operational maturity cannot support what an agent has proposed.</p><p>That work is difficult to measure with lines of code.</p><h3>But developers should not stop coding</h3><p>If developers move too far away from implementation, they can lose the feedback loop that keeps architectural judgement grounded.</p><p>You learn something different when you build a design than when you only approve it. You discover awkward boundaries. You discover that an abstraction that looked elegant on the whiteboard is painful in production.</p><p>That does not mean developers should reject agents and return to typing every line.</p><p>It means implementation should remain part of the learning loop.</p><p>A developer might let an agent write most of a feature and still understand the result deeply enough to challenge the design.</p><p>The goal is not maximum manual coding. It is enough contact with the system to keep judgement grounded.</p><h3>What happens to architects?</h3><p>Architects do not disappear because developers use agents.</p><p>In fact, their role can become more important as the number of architectural decisions made quickly increases.</p><p>The architect sees beyond one task, one service or one team.</p><p>They think about system boundaries, long-term evolution, reliability, security, operational complexity, organisational constraints and migration strategy.</p><p>Developers may take on more architectural responsibility. Architects still provide system-level perspective and accountability.</p><p>The future is not developers replacing architects, or architects replacing developers.</p><p>It is a larger decision surface, with AI doing more implementation and engineers taking responsibility for more of the decisions around it.</p><h3>What companies should measure</h3><p>If AI makes implementation abundant, lines of code become an even weaker proxy for engineering value.</p><p>A better question is:</p><p>How much valuable software can the organisation safely own?</p><p>That means asking whether the team can understand, change, operate and recover the system as it grows.</p><p>AI can increase that capacity. It can also increase complexity faster than the organisation can absorb it.</p><p>The strongest organisations will use agents to give developers and architects more room to think, question and simplify.</p><h3>The opportunity is a better engineer, not a smaller engineer</h3><p>The positive future is not that developers stop coding.</p><p>It is that developers spend less of their limited attention on mechanical work and more on the decisions that determine whether software is useful, reliable and worth maintaining.</p><p>Agents can make implementation cheaper and experimentation faster. Used well, that should raise the level of engineering work.</p><p>The developer becomes less of a typist and more of an owner of trade-offs.</p><p>The architect becomes less of a gatekeeper and more of a steward of system-level consequences.</p><p>AI writes the code.</p><p><strong>Humans still own the consequences.</strong></p><h3>A question for developers and architects</h3><p>If an AI agent can implement most of a feature, what should a senior developer still insist on doing personally?</p><p>At what point does delegation become architectural abdication?</p><p>If agents can make architectural choices, what should remain a human responsibility?</p><p>If developers write less code, what should replace lines of code as a measure of engineering skill?</p><h3>Want to go deeper?</h3><p><strong>Architecture Without Architects</strong></p><p>Research on architectural decisions made implicitly by coding agents.</p><p><strong>Developers’ Dilemma</strong></p><p>Research on hybrid developer roles, supervision and the risk of skill erosion.</p><p><strong>Towards AI as a Collaborative Partner</strong></p><p>Google Research on developer-agent collaboration, quality and engineering standards.</p><p><strong>Agents That Teach</strong></p><p>Research on the learning costs of delegating implementation to coding agents.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c3ec2a098fb9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AI Slop Is Cheap. Technical Debt Isn’t.]]></title>
            <link>https://medium.com/@duraidw/ai-slop-is-cheap-technical-debt-isnt-7d239b6135f1?source=rss-aa10e04bba51------2</link>
            <guid isPermaLink="false">https://medium.com/p/7d239b6135f1</guid>
            <category><![CDATA[claude-code]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Duraid Wadie]]></dc:creator>
            <pubDate>Sat, 22 Aug 2026 11:03:46 GMT</pubDate>
            <atom:updated>2026-08-22T15:58:42.201Z</atom:updated>
            <content:encoded><![CDATA[<p><em>AI has made code and conent generation cheap. The harder question is whether engineering judgement can scale with it.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Jf2bNxVe5GcoO6d3e-HQkg.jpeg" /><figcaption>Designed by Freepik</figcaption></figure><h3>What you’ll take away</h3><p>· Why developers may become more important, not less, as agents take over implementation</p><p>· What companies should measure instead of simply counting AI-generated code</p><p>· Why faster code generation can make engineering judgement more valuable</p><p>· Why comprehension debt can become technical debt</p><p>· Where the hidden cost of AI slop actually appears</p><p>· Why AI-generated code changes the economics of software development</p><p><strong>The cheapest code can become the most expensive code</strong></p><p>The most expensive code in a codebase may soon be the code that was almost free to write.</p><p>That sounds backwards until two costs are separated.</p><p>The first is production. An AI coding agent can generate a feature, modify several files, write tests, inspect failures and try again in a fraction of the time a developer might once have spent doing the same work manually.</p><p>The second is judgement. Someone still has to decide whether the feature belongs in the system, whether the design fits the architecture, whether the tests prove the right behaviour, and whether another engineer can safely change the result later.</p><p>AI is reducing the first cost dramatically. The second cost has not disappeared.</p><p>That is the real problem behind the current conversation about AI slop in software.</p><p>AI slop is an output problem. Comprehension debt is an understanding problem. Technical debt is one possible place where the future cost appears.</p><p>They are related. They are not synonyms.</p><p><strong>The obvious explanation is not enough</strong></p><p>The easy story is that AI coding tools generate bad code.</p><p>That story is attractive because it is simple, and because there is evidence that AI-authored changes can introduce quality problems.</p><p>But it is incomplete.</p><p>AI can produce useful code. It can remove repetitive work, help developers explore unfamiliar APIs, generate tests, explain existing code and accelerate prototypes. A generated implementation can also be cleaner than a rushed manual implementation.</p><p>So the interesting question is not whether AI can write bad code.</p><p>Developers already know that.</p><p>The interesting question is what happens when the cost of producing another piece of software becomes so low that teams can produce code faster than they can evaluate what deserves to remain.</p><p><strong>AI slop has entered software</strong></p><p>AI slop is already an established term for low-quality AI-generated digital content. In software, researchers are now using the term for generated code, pull requests, documentation and bug reports that create work for the people who have to review, maintain or trust them.</p><p>Baltes, Cheong and Treude analysed 1,154 Reddit and Hacker News posts about AI-assisted software development. Their study identified review friction, quality degradation, and wider systemic consequences. The authors argue that individual productivity gains can externalise costs onto reviewers, maintainers and the wider software community.</p><p>A second paper from the same researchers frames AI slop in software as a commons problem. Its central observation is that generated output is cheap, while the review layer that has to absorb it is limited.</p><p>That research establishes an important part of the story.</p><p>It does not establish that all AI-generated code is slop.</p><p>It also leaves room for a harder question: what happens when the problem is not only poor output, but the growing volume of output that a team has to understand?</p><p><strong>The evidence shows persistence, not an AI verdict</strong></p><p>A 2026 empirical study examined 304,362 verified AI-authored commits across 6,275 GitHub repositories and five AI coding assistants. Researchers identified 484,606 distinct issues. Code smells accounted for 89.1% of those issues. More than 15% of commits from every assistant studied introduced at least one issue, although rates differed by tool. Most importantly, 24.2% of tracked AI-introduced issues were still present in the latest repository revision studied.</p><p>The result should not be inflated into a claim that AI makes software worse overall.</p><p>It answers a narrower question: can AI-authored changes introduce issues that survive? Yes.</p><p>That matters for technical debt because persistence is part of the problem. A mistake that is fixed immediately is a defect. A problem that survives and raises the cost of future change can become debt.</p><p>The evidence therefore supports a more careful conclusion than either extreme. AI is neither a guaranteed source of technical debt nor a free productivity multiplier. The outcome depends on what happens between generation and acceptance.</p><p><strong>The bottleneck is moving</strong></p><p>Imagine an agent that can produce ten times as much code as a developer could comfortably write and inspect in the same period.</p><p>The obvious productivity metric goes up.</p><p>The harder question is review capacity.</p><p>Someone still has to decide whether an abstraction is necessary. Someone has to understand why a retry loop exists. Someone has to notice that a new wrapper duplicates an existing capability. Someone has to ask what happens when traffic is ten times higher or when a dependency becomes unavailable.</p><p>Generation can scale through parallel agents. Human judgement does not scale in the same way.</p><p>That creates a bottleneck shift.</p><p>Before AI, implementation time often constrained how much software a team could produce. With agentic tools, comprehension, review and architectural judgement can become the constraint instead.</p><p>That is why ‘AI makes developers faster’ is an incomplete engineering statement. Faster generation is not the same as faster delivery of software that remains safe and inexpensive to change.</p><p><strong>The AI tool has a price. The code it produces has a cost.</strong></p><p>An AI coding tool has a visible price. It might be a subscription, an API bill, or infrastructure and inference costs. That number is easy to put on a budget.</p><p>The harder cost is the engineering work that happens after generation.</p><p>A developer reviews the pull request. Another engineer checks the architecture. Tests are added or corrected. Generated code is simplified. Dependencies are examined. An unexpected behaviour is debugged. Six months later, someone has to understand the implementation before changing it.</p><p>Those costs may never appear on the AI tooling invoice.</p><p>They can still be larger than the invoice.</p><p>This is why AI tooling cost and AI technical debt should not be treated as the same thing. The tool is an input cost. Technical debt is a future cost created by decisions that make the system more expensive to change or maintain.</p><p>The connection is economic: when the input cost of generating code falls sharply, it becomes easier to accept output whose downstream cost has not been measured.</p><p>Consider a simple hypothetical. If an AI tool costs a company 100 dollars per developer each month, but the generated output causes one additional hour of review or rework per developer each week, the software bill is no longer the main number. The labour cost of absorbing the output may dominate it.</p><p>The exact amount will vary by company, developer compensation, tooling and workflow. The point is not the example’s dollar value. The point is what the example makes visible: the cheapest part of AI-assisted development may be the part that gets measured most carefully.</p><p>A useful AI economics model has three layers: the cost of the tool, the cost of supervising its output, and the future cost of maintaining what survives.</p><p><strong>A small example reveals the difference</strong></p><p>Suppose a service already has a validation component used by four endpoints.</p><p>A new requirement needs one additional rule.</p><p>The simplest engineering decision might be to extend the existing component.</p><p>An AI agent could instead generate a new validation interface, an adapter, a helper, a configuration object and tests around the new path. The feature works. The tests pass. The pull request looks complete.</p><p>Nothing has obviously failed.</p><p>But the next engineer now has more concepts to understand when the rule changes. The new path may also create two places where validation behaviour can diverge.</p><p>The original task was cheaper.</p><p>The system became more expensive.</p><p>That is the kind of second-order effect a velocity dashboard cannot see.</p><p><strong>Comprehension debt is the missing middle</strong></p><p>Addy Osmani’s 2026 work on comprehension debt gives this problem a useful name. He describes comprehension debt as the growing gap between how much code exists in a system and how much of it humans genuinely understand.</p><p>A separate 2026 study of GenAI-assisted software engineering projects describes the same problem as a gap between what a team knows about its codebase and what it needs to understand to maintain and modify it effectively. The study examined 621 reflective diaries from 207 students and identified patterns including black-box acceptance of AI code and verification bypass.</p><p>Comprehension debt is not the same thing as technical debt.</p><p>Technical debt is a cost embedded in engineering decisions and system structure. Comprehension debt is a gap in the team’s ability to explain and reason about the system.</p><p>That difference matters because code can be clean enough to pass tests while the people responsible for it know less about why it works.</p><p>AI can increase that gap if generated code is accepted faster than the team builds a mental model of it.</p><p>The same tools can also reduce it when they are used to explain data flow, challenge assumptions, compare designs and teach the system back to its maintainers.</p><p>AI therefore does not determine the debt by itself. The workflow does.</p><p><strong>Why cheap production changes behaviour</strong></p><p>Software has always contained shortcuts. AI did not invent technical debt.</p><p>What changes is the price of another attempt.</p><p>Another wrapper can be generated in seconds. Another helper can be generated in seconds. Another abstraction can be generated in seconds.</p><p>Cheap experimentation is valuable if experiments are actually treated as experiments.</p><p>The problem appears when generated work becomes permanent simply because removing it feels harder than leaving it alone.</p><p>One unused helper is insignificant. Repeat the decision hundreds of times and the system begins carrying choices that nobody consciously chose to keep.</p><p>This is the economic connection between AI slop and technical debt.</p><p>When production becomes cheap, the threshold for saying yes falls.</p><p>The engineering discipline has to move upstream. The team has to decide what deserves to become part of the system.</p><p><strong>The strongest counterargument</strong></p><p>There is a serious case against this thesis.</p><p>AI agents are improving. They can inspect repositories, run tests, search documentation, refactor code and operate across multiple files. Better automated verification could catch problems that humans miss. In some workflows, AI may reduce existing technical debt by making refactoring and maintenance cheaper.</p><p>That is plausible.</p><p>If those capabilities continue to improve, some of today’s review burden may disappear.</p><p>But the underlying constraint does not disappear. It changes form.</p><p>Someone, human or machine, still needs to verify that the generated change satisfies the real requirements, preserves important invariants and behaves safely under conditions the tests do not cover.</p><p>If AI takes over more verification, then the verification system itself becomes part of the architecture that must be trusted.</p><p>The future may contain less manual line-by-line review. It will not contain less need for justified engineering decisions.</p><p><strong>What engineering productivity should measure next</strong></p><p>The useful question is not how much code an AI assistant generated.</p><p>That number can increase while the system gets harder to operate.</p><p>A better question is how much valuable software the organisation can produce without increasing the cost of safely changing what it already owns.</p><p>That requires different signals.</p><p>Can another engineer explain the change without consulting the original prompt? Can the team identify the assumptions that would fail at ten times the traffic? Does the new abstraction replace something or merely add another layer? Do the tests demonstrate intended behaviour? Can the feature be removed without discovering that several unrelated parts now depend on it?</p><p>These are not anti-AI measures.</p><p>They measure whether AI is increasing engineering capacity rather than simply increasing code volume.</p><p><strong>The companies that win will invest in developers</strong></p><p>There is a temptation to think the AI race is primarily about tools.</p><p>Which model? Which coding agent? Which platform? Which company has the biggest AI budget?</p><p>But the evidence points somewhere more human.</p><p>DORA’s research describes AI as an amplifier of existing organisational strengths and weaknesses. Its 2026 research also reports that AI accelerates initial code generation while time saved in creation is often reallocated to auditing and verification. Higher AI adoption has been associated with both increased delivery throughput and increased delivery instability.</p><p>That puts developers back at the centre of the story.</p><p>The developer still decides whether an abstraction makes sense.</p><p>The developer still notices when generated code does not fit the architecture.</p><p>The developer still decides what should be deleted.</p><p>The developer still has to understand the system when production breaks at 2 a.m.</p><p>AI can make that developer faster.</p><p>It cannot make the developer irrelevant.</p><p>If anything, the opposite may happen.</p><p>As code generation becomes cheaper, good developers become more valuable because judgement becomes scarcer.</p><p>The companies that win may therefore not be the companies that generate the most code.</p><p>They may be the companies that create the best environment for developers to exercise judgement: strong internal platforms, good feedback loops, clear architecture, useful tests, healthy teams and enough time to understand what they are building.</p><p>Developer. Developer. Developer.</p><p>The technology creates the leverage. Developers decide where to apply it, what trade-offs to accept, and what should never reach production.</p><p><strong>The opportunity is bigger than the risk</strong></p><p>AI does not have to make software harder to understand. Used well, it can give engineers more time for the work that machines are still poor at: making trade-offs, questioning assumptions, simplifying systems and deciding what is worth building.</p><p>The best teams will not be the ones that reject AI, or the ones that generate the most code. They will be the ones that learn how to use AI to increase their engineering judgement rather than replace it.</p><p>That is a more optimistic future for AI-assisted development: more experimentation, faster learning, better maintenance and less time spent on work that should never have existed.</p><p>Generate more. Understand more. Build less that you do not need.</p><p><strong>What do you think?</strong></p><p>Is AI actually creating more technical debt, or is it exposing weaknesses that already existed in the way teams review and maintain software?</p><p>Have you found AI-generated code that worked perfectly but became difficult to understand later?</p><p>How does your team measure the real cost of AI-assisted development beyond the AI tooling bill?</p><p>And where do you draw the line between useful AI-assisted development and AI slop?</p><p><strong>Want to go deeper?</strong></p><p><strong>Comprehension Debt: The Hidden Cost of AI-Generated Code</strong></p><p>Addy Osmani’s detailed exploration of what happens when AI-generated code grows faster than the team’s understanding of the system.</p><p><strong>AI Slop and the Software Commons</strong></p><p>A research perspective on how cheap AI-generated output can shift review and maintenance costs onto other engineers and the wider software community.</p><p><strong>An Endless Stream of AI Slop</strong></p><p>A study of how developers themselves describe the growing burden of AI-assisted software development.</p><p><strong>Debt Behind the AI Boom</strong></p><p>A large-scale empirical study of more than 300,000 verified AI-authored commits and the issues associated with them.</p><p><strong>DORA: Balancing AI tensions</strong></p><p>Current DORA research on the trade-off between faster code generation, auditing and verification, and software delivery stability.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7d239b6135f1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Hidden Cost of Claude Code The Problem Nobody Notices Until It’s Everywhere]]></title>
            <link>https://medium.com/@duraidw/the-hidden-cost-of-claude-code-the-problem-nobody-notices-until-its-everywhere-23cbe23ef811?source=rss-aa10e04bba51------2</link>
            <guid isPermaLink="false">https://medium.com/p/23cbe23ef811</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[claude-code]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[software-architecture]]></category>
            <dc:creator><![CDATA[Duraid Wadie]]></dc:creator>
            <pubDate>Tue, 21 Apr 2026 21:58:00 GMT</pubDate>
            <atom:updated>2026-04-21T21:58:30.144Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rCO3Fc10tNYt6EBXjTAcfg.jpeg" /><figcaption>Designed by Freepik</figcaption></figure><p><strong>Date:</strong> April 19, 2026 | Author: Duraid Wadie</p><p>Something feels off about AI in engineering right now. Not in a this does not work way, in the opposite way. It works too well.</p><p>You try something small with Claude Code. It writes code, fixes something annoying, saves you time you did not want to spend. You think you have just found leverage. Most people immediately jump to the same conclusion. This is going to reduce cost.</p><p>That is where almost everyone gets it wrong.</p><p>Claude Code does not reduce cost. It removes friction. And once you remove friction, people naturally do more. More code, more tools, more small systems, more let’s just try this quickly moments. None of that feels expensive when you are doing it. It feels like productivity. But that is exactly why it becomes expensive at scale.</p><p>You do not see the problem at the start. You see it later, when every engineer is using it constantly, when prompts get retried again and again, when workflows start depending on it. At that point AI is no longer a tool sitting on the side. It becomes part of how work actually happens.</p><p>That is the shift most companies are underestimating.</p><p>When large companies like Uber started pushing AI deeper into engineering workflows, the outcome was not failure, it was adoption. Engineers used it heavily, productivity increased, but the AI budget ran out faster than expected. Not because the tool did not work, but because it worked exactly as intended. More usage meant more cost, and it scaled faster than hiring ever could. That is the real signal here. The risk is not low adoption. It is successful adoption.</p><p>Claude Code makes this even more pronounced because it sits closer to execution. It does not just suggest code. It reads your codebase, edits files, runs commands, and helps complete real tasks. You are no longer just asking questions, you are delegating work. And once you delegate work to something that costs money per use, you have effectively created a cost engine, not a cost reducer.</p><p>If you watch how engineers actually use it, the pattern is obvious. Nobody runs one prompt and moves on. They tweak, retry, regenerate, refine, sometimes five or ten times, until the output feels right. That behaviour feels harmless in isolation, but across teams it multiplies quickly. Small inefficiencies at the individual level turn into large costs at the organisation level.</p><p>There is another layer to this that shows up later. Claude Code does not just make teams faster, it makes them build more. More internal tools, more services, more quick solutions that did not exist before. Each one solves a problem in the moment, but none of them disappear. They need to run, they need to be maintained, and they need to behave consistently. So even if AI reduces effort upfront, it increases the amount of system you have to support afterwards. That is the part most people do not model.</p><p>You can see this clearly in how teams are starting to replace SaaS tools. The thinking is simple. Why pay for a tool when we can build it ourselves with Claude Code. And they are right, they can. Companies like Vercel have openly talked about rebuilding internal tools instead of renewing subscriptions. It works, especially at the start. But then that tool becomes your responsibility. It needs reliability, updates, ownership. You did not remove cost, you just moved it from a vendor into your own system, where it is harder to track.</p><p>Agents push this even further. Claude Code is no longer just something engineers use manually, it is being embedded into workflows. It can run tasks, trigger processes, and interact with systems without someone sitting there each time. That is powerful, but it also means cost is no longer tied to a person. It can run continuously, and if you are not careful, it grows without the same level of visibility.</p><p>This is the uncomfortable truth most enterprises are only starting to realise. AI did not reduce engineering cost, it changed the cost structure. It moved it from something predictable and mostly fixed into something driven by behaviour, usage, and scale. And most organisations are still operating as if nothing changed.</p><p>The real question is not how much faster you can build with Claude Code. It is whether you can afford how you are using it when it scales. Because small usage feels cheap. Scaled usage behaves very differently.</p><p>The teams that make this work are not the ones using AI everywhere. They are the ones being deliberate about it. They use it where it creates clear leverage, repetitive tasks, boilerplate, codebase exploration, and avoid it where consistency and determinism matter. They make cost visible to engineers, not just finance, because behaviour only changes when people can see the impact of what they are doing. They treat AI output as untrusted by default, which means more validation and testing, not less. And they put boundaries around where agents can operate, because once agents are running across systems, they do not naturally stop.</p><p>Claude Code is not just another developer tool. It is a new layer in the system, and like any layer, if you do not design it properly, it becomes the most expensive one.</p><h3>What this looks like in a real enterprise team</h3><p>This is roughly how it plays out in practice.</p><p>A large engineering team rolls out Claude Code across multiple squads. At first it is used for simple tasks. Writing small functions, debugging issues, generating test cases. Nothing unusual.</p><p>Then usage grows.</p><p>Engineers start using it for almost everything. Instead of writing logic directly, they describe what they want. Instead of fixing bugs manually, they ask for suggestions. Instead of thinking through a problem, they explore options through repeated prompts.</p><p>At the same time, teams start building internal tools instead of buying them. A reporting dashboard here. A workflow tool there. A small service to automate something that used to be manual. All of it created quickly, often in days.</p><p>Within a few months, two things happen.</p><p>First, the volume of AI usage becomes constant. Not occasional, not task-based, but continuous throughout the day across teams. Every engineer is interacting with it dozens or hundreds of times.</p><p>Second, the system surface grows. More services, more internal tools, more moving parts. Each one needs to run, be monitored, and be maintained.</p><p>That is when cost starts to show up.</p><p>Not as a single spike, but as a pattern. Higher than expected usage, increasing infrastructure load, more time spent maintaining what was quickly built. And because it grew gradually, it was not obvious when the shift happened.</p><p>This is not a failure scenario. It is a success scenario.</p><p>The teams moved faster. They built more. They delivered more.</p><p>But they also created a system where cost scales with behaviour, not just with headcount.</p><p>That is the part most organisations are still learning how to control.</p><h3>Final thought</h3><p>The companies that win this phase will not be the ones using AI the most.</p><p>They will be the ones who understand where it creates leverage, where it creates cost, and when not to use it at all.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=23cbe23ef811" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AI DLC What a Real AI-Driven Software Lifecycle Actually Looks Like]]></title>
            <link>https://medium.com/@duraidw/ai-dlc-what-a-real-ai-driven-software-lifecycle-actually-looks-like-b525329d7a13?source=rss-aa10e04bba51------2</link>
            <guid isPermaLink="false">https://medium.com/p/b525329d7a13</guid>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[saas]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Duraid Wadie]]></dc:creator>
            <pubDate>Sat, 04 Apr 2026 14:12:42 GMT</pubDate>
            <atom:updated>2026-04-04T14:12:42.130Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CLtjtxxX7S40SD2cCMEvtg.png" /></figure><p><strong>Date:</strong> April 04, 2026| Author: Duraid Wadie</p><p>I keep hearing this idea:</p><p><em>“AI will replace the SDLC”</em></p><p>At first, it sounds like one of those overreactions.</p><p>Like when agile was supposed to replace everything.<br>Or DevOps was supposed to eliminate complexity.</p><p>It never really works like that.</p><p>But something is changing.</p><p>Not whether we have a lifecycle.</p><p>But how that lifecycle behaves.</p><h3>The wrong way to think about it</h3><p>Most people imagine this:</p><ul><li>no planning</li><li>no structure</li><li>just describe what you want → AI builds it</li></ul><p>That’s not how real systems work.</p><p>Because software isn’t just code.</p><p>It’s:</p><ul><li>constraints</li><li>trade-offs</li><li>failure modes</li><li>long-term consequences</li></ul><p>AI doesn’t remove those.</p><p>So no AI doesn’t replace the SDLC.</p><p>But it does change who executes it.</p><h3>The real shift</h3><p>Traditional SDLC looks like this:</p><blockquote><em>humans execute → tools assist</em></blockquote><p>What’s emerging now looks more like:</p><blockquote><em>agents execute parts → humans supervise and decide</em></blockquote><p>That’s the shift.</p><p>And once you see it, you start noticing it everywhere.</p><h3>You can already see fragments of this</h3><p>Not in one place.</p><p>But across real teams.</p><p>Engineers are:</p><ul><li>generating code before designing everything</li><li>building internal tools instead of buying SaaS</li><li>validating systems continuously, not at the end</li><li>using AI to debug before they investigate manually</li></ul><p>None of this removes the SDLC.</p><p>But it weakens the boundaries between steps.</p><h3>The SDLC isn’t gone it’s becoming a loop</h3><p>Instead of:</p><ul><li>plan → build → test → deploy</li></ul><p>You get something closer to:</p><blockquote><em>describe → generate → validate → adjust</em></blockquote><p>And then repeat.</p><p>That’s what people are starting to call “AI DLC”.</p><p>Not a replacement.</p><p>A different shape.</p><h3>Where this breaks if you’re not careful</h3><p>This is where most of the hype falls apart.</p><p>If teams take this too far:</p><ul><li>they skip structure</li><li>trust generated code too much</li><li>lose architectural discipline</li></ul><p>And you end up with:</p><ul><li>fragile systems</li><li>hidden complexity</li><li>problems that only show up at scale</li></ul><p>AI makes it easier to build.</p><p>It doesn’t guarantee what you build is good.</p><h3>The uncomfortable part</h3><p>The value of “writing code fast” is dropping.</p><p>Because now:</p><ul><li>code can be generated quickly</li><li>prototypes can be built in minutes</li></ul><p>So the real value shifts to:</p><blockquote><em>understanding systems<br>making good decisions<br>knowing what should exist</em></blockquote><p>Not just building faster.</p><h3>So what is AIDLC, really?</h3><p>It’s not a new framework.</p><p>It’s not a new methodology.</p><p>It’s what happens when:</p><blockquote><em>execution becomes partially automated</em></blockquote><p>And once execution changes…</p><p>everything around it shifts.</p><h3>What the Full AIDLC Flow Actually Looks Like</h3><p>If you strip everything back, this is what an AI-driven lifecycle looks like in practice.</p><p>Not theory.<br> Just how a real team could operate.</p><h3>1. Intent (not requirements)</h3><p>It starts with:</p><ul><li>a problem</li><li>constraints</li><li>expected outcome</li></ul><p>Not a long spec.</p><p>Something like:</p><blockquote><em>“We need a service that processes orders, handles retries, and exposes an API for downstream systems.”</em></blockquote><p>Instead of writing documentation first:</p><ul><li>the engineer defines intent</li><li>adds constraints (scale, latency, data rules)</li></ul><h3>2. Agent generates first system version</h3><p>An agent then:</p><ul><li>proposes architecture (services, APIs, data model)</li><li>generates initial codebase</li><li>scaffolds the system</li></ul><p>At this point, you already have:</p><ul><li>working endpoints</li><li>basic logic</li><li>initial structure</li></ul><p>Not perfect.</p><p>But real.</p><h3>3. Engineer reviews and reshapes</h3><p>Now the role shifts.</p><p>The engineer:</p><ul><li>validates structure</li><li>removes bad assumptions</li><li>adjusts architecture</li><li>rewrites critical parts</li></ul><p>This is not editing.</p><p>This is <strong>taking ownership</strong>.</p><h3>4. Agent generates tests + validation</h3><p>Instead of writing tests from scratch:</p><ul><li>agent generates test cases</li><li>suggests edge scenarios</li><li>simulates failure paths</li></ul><p>Engineer then:</p><ul><li>reviews test quality</li><li>adds missing edge cases</li><li>validates behaviour</li></ul><p>Testing is now happening <strong>during development</strong>, not after.</p><h3>5. Agent prepares deployment</h3><p>The agent:</p><ul><li>generates pipeline configs</li><li>suggests environment setup</li><li>highlights potential risks</li></ul><p>Engineer:</p><ul><li>validates infra decisions</li><li>ensures compliance and safety</li></ul><p>Deployment becomes:</p><blockquote><em>assisted, not manual</em></blockquote><h3>6. Agent monitors and analyses</h3><p>Once live:</p><ul><li>agent watches logs</li><li>detects anomalies</li><li>correlates issues</li><li>suggests root causes</li></ul><p>Engineer:</p><ul><li>confirms findings</li><li>makes final decisions</li></ul><p>No more starting from zero.</p><h3>7. Continuous adjustment loop</h3><p>Instead of “maintenance cycles”:</p><ul><li>agent suggests improvements</li><li>identifies inefficiencies</li><li>proposes refactors</li></ul><p>Engineer:</p><ul><li>approves or rejects</li><li>guides evolution</li></ul><p>The system is never static.</p><h3>The whole flow in one line</h3><p>If you compress it, AIDLC looks like this:</p><blockquote><em>intent → generate → review → validate → deploy → monitor → adjust → repeat</em></blockquote><h3>The real difference</h3><p>In SDLC:</p><blockquote><em>humans execute every step</em></blockquote><p>In AIDLC:</p><blockquote><em>agents execute parts of each step<br>humans supervise and decide</em></blockquote><h3>The takeaway</h3><p>If you’re still thinking in:</p><ul><li>rigid phases</li><li>manual execution</li><li>heavy handoffs</li></ul><p>You’re already behind.</p><p>But if you think this removes the need for:</p><ul><li>architecture</li><li>discipline</li><li>ownership</li></ul><p>You’ll build faster…</p><p>and break things worse.</p><h3>Final thought</h3><p>AI didn’t remove the lifecycle.</p><p>It changed who does the work inside it.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b525329d7a13" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Death by Claude The Dangerous Idea Everyone Is Missing]]></title>
            <link>https://medium.com/@duraidw/death-by-claude-the-dangerous-idea-everyone-is-missing-db4f71fe74b1?source=rss-aa10e04bba51------2</link>
            <guid isPermaLink="false">https://medium.com/p/db4f71fe74b1</guid>
            <category><![CDATA[saas]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[software]]></category>
            <category><![CDATA[technology]]></category>
            <dc:creator><![CDATA[Duraid Wadie]]></dc:creator>
            <pubDate>Sat, 14 Mar 2026 13:51:45 GMT</pubDate>
            <atom:updated>2026-04-09T15:34:46.610Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/740/1*w4SJFys8jJ0LPw6vtkBdPg.jpeg" /><figcaption>Designed by Freepik</figcaption></figure><p><strong>Date:</strong> March 14, 2026| Author: Duraid Wadie</p><p>There’s a site going around.</p><p>You type in a SaaS company name.<br>It gives you a prompt.<br>And suddenly… it looks like you can rebuild the whole product.</p><p>It’s called <em>Death by Claude</em>.</p><p>At first, it feels like a joke.</p><p>Then you try it.</p><p>And it gets uncomfortable.</p><p>Because the output isn’t nonsense.</p><p>It’s… plausible.</p><p>That’s the part people are reacting to.</p><blockquote><em>“If I can generate this in minutes, why does this company exist?”</em></blockquote><p>And from there, the narrative writes itself:</p><p>But something about that feels off.</p><p>Not wrong.</p><p>Just incomplete.</p><h3>The part that is real</h3><p>Let’s not dismiss it.</p><p>There’s a real shift here.</p><p>AI can now:</p><blockquote>generate working features</blockquote><blockquote>scaffold products</blockquote><blockquote>recreate large parts of esisting tools</blockquote><p>And yes some teams are already doing this.</p><p>You can see it in companies like Vercel, where internal tools are being rebuilt instead of renewed.</p><p>That’s not theory.</p><p>That’s behaviour.</p><p>So the threat is real.</p><p>But it’s not where most people think it is.</p><h3>The part everyone skips</h3><p>Generating software is not the hard part anymore.</p><p>The hard part is this:</p><blockquote><em>making sure it behaves the same way tomorrow as it did today</em></blockquote><p>That’s where most of these “AI can rebuild anything” arguments fall apart.</p><p>Because production software is not just:</p><p>It’s:</p><p>And AI doesn’t guarantee any of those.</p><h3>The real problem with “rebuild it with AI”</h3><p>When you generate a system from prompts:</p><p>You’re not engineering the system.</p><p>You’re <strong>sampling it</strong>.</p><p>And sampling has a property people don’t talk about enough:</p><blockquote><em>it can change between runs</em></blockquote><p>That’s fine for:</p><blockquote>content</blockquote><blockquote>drafts</blockquote><blockquote>internal tools</blockquote><p>It’s dangerous for:</p><blockquote>billing systems</blockquote><blockquote>financial logic</blockquote><blockquote>data processing pipelines</blockquote><p>Anywhere consistency matters.</p><h3>A real example (this is where things get clearer)</h3><p>We worked on rebuilding a system recently.</p><p>Not from scratch from an existing product.</p><p>Two senior engineers.<br>A few months.<br>Heavy AI usage.</p><p>It worked.</p><p>But not for the reason people think.</p><p>It worked because:</p><blockquote>the old system existed</blockquote><blockquote>outputs were measurable</blockquote><blockquote>behavior was testable</blockquote><p>We could:</p><blockquote>run old vs new</blockquote><blockquote>compare outputs continuously</blockquote><blockquote>detect any deviation</blockquote><p>Every change had a reference point.</p><p>That’s the difference.</p><h3>What Death by Claude gets right (and wrong)</h3><p>It gets one thing very right:</p><blockquote><em>software is easier to generate than ever before</em></blockquote><p>But it misses the constraint that actually matters:</p><blockquote><em>software still needs to be </em>validated</blockquote><p>And validation is harder with AI, not easier.</p><p>Because now you’re dealing with:</p><blockquote>generated logic</blockquote><blockquote>hidden assumptions</blockquote><blockquote>non-deterministic behavior</blockquote><p>Which means:</p><blockquote><em>you need stronger testing, not less</em></blockquote><h3>The real divide that’s emerging</h3><p>This is where things get interesting.</p><p>There are now two types of builders:</p><h3>1. Generation-first builders</h3><p>Works well for:</p><ul><li>prompt → generate → ship</li><li>minimal validation</li><li>fast iteration</li></ul><p>Breaks when:</p><ul><li>internal tools</li><li>experiments</li><li>low-risk systems</li></ul><h3>2. Validation-first builders</h3><p>Slower upfront.</p><p>But survives in production.</p><p>That’s the real divide.</p><p>Not AI vs no AI.</p><h3>The uncomfortable truth</h3><p>AI didn’t remove engineering.</p><p>It removed one illusion:</p><blockquote><em>that building the system was the hard part</em></blockquote><p>It isn’t anymore.</p><p>The hard part is:</p><ul><li>proving it works</li><li>keeping it consistent</li><li>trusting it under load</li></ul><h3>So… is SaaS actually at risk?</h3><p>Yes.</p><p>But not because it can be rebuilt.</p><p>Because:</p><blockquote><em>parts of it can be rebuilt </em>without discipline</blockquote><p>And that creates pressure.</p><p>Not replacement.</p><h3>The takeaway</h3><p>If you’re building with AI today:</p><blockquote><em>generation is not your advantage</em></blockquote><p>Validation is.</p><p>If you don’t have:</p><p>You’re not building a system.</p><p>You’re generating one.</p><p>And those are not the same thing.</p><h3>Final thought</h3><p>Death by Claude isn’t dangerous because it shows software can be rebuilt.</p><p>It’s dangerous because it makes it look easy.</p><p>And the moment something <em>looks</em> easy…</p><p>people skip the parts that actually matter.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=db4f71fe74b1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AI Is Not Just Assisting the SDLC Anymore It’s Starting to Run Parts of It]]></title>
            <link>https://medium.com/@duraidw/ai-is-not-just-assisting-the-sdlc-anymore-its-starting-to-run-parts-of-it-8f272a93ef3d?source=rss-aa10e04bba51------2</link>
            <guid isPermaLink="false">https://medium.com/p/8f272a93ef3d</guid>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[saas]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Duraid Wadie]]></dc:creator>
            <pubDate>Sat, 21 Feb 2026 13:29:30 GMT</pubDate>
            <atom:updated>2026-04-04T13:44:21.171Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/740/1*orlYq6atP-xqlOwtOIPCMg.jpeg" /><figcaption>Designed by Freepik</figcaption></figure><p><strong>Date:</strong> Feb 21, 2026| Author: Duraid Wadie</p><p>Most people still think AI in engineering means:</p><ul><li>code suggestions</li><li>faster autocomplete</li><li>maybe some debugging help</li></ul><p>That’s outdated already.</p><p>What’s actually happening inside real teams is different.</p><p>They’re not just using AI.</p><p>They’re starting to <strong>embed agents directly into the workflow</strong>.</p><p>And that changes how the SDLC behaves.</p><h3>The shift is simple (but easy to miss)</h3><p>Before:</p><blockquote><em>engineers used tools to execute steps</em></blockquote><p>Now:</p><blockquote><em>parts of the workflow are executed by agents</em></blockquote><p>That’s not the same thing.</p><p>And you can see it clearly if you look at what companies are doing.</p><h3>1. Code generation is no longer “developer initiated”</h3><h3>What it used to look like</h3><ul><li>developer writes code</li><li>maybe uses autocomplete</li><li>pushes changes</li></ul><h3>What’s happening now</h3><p>In teams using advanced AI setups:</p><ul><li>engineers describe intent</li><li>agents generate initial implementations</li><li>agents sometimes suggest structure across files</li></ul><h3>Real-world example pattern (Microsoft / GitHub ecosystem)</h3><p>Inside teams heavily using Copilot-style workflows:</p><ul><li>engineers start from generated scaffolding</li><li>iterate on top</li><li>focus more on shaping than writing</li></ul><p>Practical takeaway:</p><p>If your team still writes everything from scratch, you’re slower than you need to be.</p><p>But…</p><p>If you don’t review aggressively, you’re introducing risk.</p><h3>2. Code review is starting to include agents as first reviewers</h3><p>This is a big one.</p><h3>Before</h3><ul><li>PR created</li><li>human reviews</li><li>feedback cycle</li></ul><h3>Now</h3><p>Teams are adding:</p><blockquote><em>an agent layer before human review</em></blockquote><h3>What the agent does</h3><ul><li>scans for bugs</li><li>checks patterns</li><li>flags potential issues</li><li>suggests improvements</li></ul><h3>Real behaviour (seen across modern teams)</h3><p>By the time a human reviews:</p><ul><li>obvious issues are already flagged</li><li>basic feedback is already handled</li></ul><p>Practical takeaway:</p><p>Your reviewers should spend time on:</p><ul><li>architecture</li><li>edge cases</li><li>long-term maintainability</li></ul><p>Not syntax or simple bugs.</p><h3>3. Incident response is partially delegated to agents</h3><p>This is already happening.</p><h3>Before</h3><ul><li>engineer reads logs</li><li>traces issue</li><li>investigates manually</li></ul><h3>Now</h3><p>Agents are used to:</p><ul><li>summarise logs</li><li>correlate events</li><li>suggest root causes</li><li>propose fixes</li></ul><h3>Real-world pattern (Amazon / large-scale ops environments)</h3><p>At scale:</p><ul><li>logs are too large to manually scan</li><li>AI-assisted analysis is becoming standard</li></ul><p>But here’s the important part:</p><p>The agent doesn’t “solve” incidents.</p><p>It <strong>reduces the time to understanding</strong>.</p><p>Practical takeaway:</p><p>If your team is still manually parsing logs from scratch, you’re wasting time.</p><h3>4. Internal tools are now being built by agents, not teams</h3><p>This is one of the clearest shifts.</p><h3>Before</h3><p>You needed:</p><ul><li>a team</li><li>planning</li><li>time</li></ul><p>To build internal tools.</p><h3>Now</h3><p>Teams are doing this:</p><ul><li>describe the tool</li><li>agent generates first version</li><li>engineer refines</li></ul><h3>Real-world pattern (Shopify / modern product teams)</h3><p>Instead of adding SaaS tools:</p><ul><li>teams build internal tools faster</li><li>tailored to exact workflows</li></ul><p>Practical takeaway:</p><p>Before buying a SaaS tool, ask:</p><blockquote><em>can we generate 70% of this internally in a day?</em></blockquote><h3>5. DevOps workflows are becoming semi-autonomous</h3><p>This is less visible, but important.</p><h3>Before</h3><ul><li>engineers configure pipelines</li><li>debug failures</li><li>manage infra manually</li></ul><h3>Now</h3><p>Agents are used to:</p><ul><li>generate pipeline configs</li><li>suggest fixes on failure</li><li>optimise configurations</li></ul><h3>Real-world pattern</h3><p>In larger environments:</p><ul><li>engineers rely on AI to troubleshoot</li><li>reduce time spent on repetitive infra work</li></ul><p>Practical takeaway:</p><p>Your DevOps team should spend less time:</p><ul><li>fixing pipelines</li></ul><p>And more time:</p><ul><li>improving system reliability</li></ul><h3>6. Task execution is starting to move away from humans</h3><p>This is where agents go beyond “helping”.</p><p>Instead of:</p><ul><li>engineer triggering workflows</li><li>manually executing steps</li></ul><p>You get:</p><blockquote><em>agents executing multi-step tasks across systems</em></blockquote><h3>Example pattern</h3><ul><li>update records</li><li>trigger processes</li><li>move data</li><li>notify systems</li></ul><p>All handled by agents.</p><p>This used to require:</p><ul><li>integrations</li><li>scripts</li><li>manual steps</li></ul><p>Now it’s increasingly:</p><ul><li>intent → execution</li></ul><p>Practical takeaway:</p><p>If your workflow depends on humans coordinating tools…</p><p>it’s a candidate for replacement.</p><h3>The real change to the SDLC</h3><p>If you step back, the SDLC isn’t gone.</p><p>But the roles inside it are shifting.</p><h3>Before</h3><ul><li>humans executed each step</li><li>tools supported them</li></ul><h3>Now</h3><ul><li>agents execute parts of steps</li><li>humans supervise and decide</li></ul><p>That’s the shift.</p><h3>The risk (this is important)</h3><p>This doesn’t just make things better.</p><p>It introduces new problems:</p><ul><li>hidden bugs from generated code</li><li>over-reliance on suggestions</li><li>loss of deep understanding</li></ul><p>And weaker teams will:</p><ul><li>move faster</li><li>but build worse systems</li></ul><h3>The new bottleneck</h3><p>It’s not coding anymore.</p><p>It’s:</p><blockquote><em>knowing what should be built<br>and whether it should be trusted</em></blockquote><h3>The takeaway</h3><p>If you’re running engineering teams:</p><blockquote><em>don’t just “add AI”</em></blockquote><p>You need to:</p><ul><li>embed agents into workflows</li><li>redesign how work flows</li><li>shift engineers from execution → supervision</li></ul><h3>What I’d do differently</h3><ul><li>introduce agent-first code review</li><li>automate first-pass incident analysis</li><li>build internal tools instead of buying</li><li>redesign workflows around execution, not interaction</li></ul><h3>Final thought</h3><p>AI isn’t just speeding up the SDLC.</p><p>It’s starting to take over parts of it.</p><p>And the teams that benefit aren’t the ones using AI tools.</p><p>They’re the ones restructuring how work happens.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8f272a93ef3d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The SaaS Apocalypse What’s Actually Changing]]></title>
            <link>https://medium.com/@duraidw/the-saas-apocalypse-whats-actually-changing-08101e8c167b?source=rss-aa10e04bba51------2</link>
            <guid isPermaLink="false">https://medium.com/p/08101e8c167b</guid>
            <category><![CDATA[software]]></category>
            <category><![CDATA[saas]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[systems-thinking]]></category>
            <dc:creator><![CDATA[Duraid Wadie]]></dc:creator>
            <pubDate>Sat, 10 Jan 2026 13:03:01 GMT</pubDate>
            <atom:updated>2026-04-10T13:39:38.772Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/740/1*y_cvxR-NZbsczOYyov2grw.jpeg" /><figcaption>Designed by Freepik</figcaption></figure><p><strong>Date:</strong> Jan 10, 2026 | Author: Duraid Wadie</p><p>Something is changing.</p><p>Not in a dramatic “everything collapses tomorrow” way.<br>More like… things that used to feel essential are now being questioned.</p><p>And that usually means something deeper is shifting.</p><p>People keep calling it the <em>“SaaS apocalypse.”</em></p><p>Most takes miss the point.</p><blockquote><em>“AI is killing SaaS”<br>“Nothing is changing, it’s just another cycle”</em></blockquote><p>Neither is accurate.</p><h3>What’s actually happening</h3><p>AI isn’t killing SaaS.</p><p>It’s reducing the amount of <strong>human effort required to get work done</strong>.</p><p>And SaaS, whether we admit it or not, was built around that effort.</p><p>Most SaaS models assume:</p><p>That’s where usage comes from. That’s where revenue scales.</p><p>So when the amount of human work drops…</p><p>the surface area of SaaS shrinks.</p><h3>Where AI agents change the game</h3><p>AI tools were the first step.</p><p>AI agents are the second.</p><p>And the second step is where things get serious.</p><p>Instead of:</p><ul><li>using tools to assist<br>You now have:</li><li>systems that <strong>execute tasks across tools</strong></li></ul><p>That means:</p><blockquote><em>fewer clicks<br>fewer users<br>fewer reasons to pay for multiple SaaS products</em></blockquote><h3>What AI tools are already replacing (today)</h3><p>This is not future. This is already happening.</p><h3>1. Simple content and writing SaaS</h3><p>Tools that existed just to:</p><p>These are already being replaced.</p><p>Now:</p><ul><li>one general AI tool can do all of this</li><li>faster, cheaper, and in one place</li></ul><p>You don’t need a dedicated SaaS for it anymore.</p><h3>2. Basic analytics and reporting tools</h3><p>A lot of SaaS products exist just to:</p><p>Now AI can:</p><blockquote>query data directly</blockquote><blockquote>explain trends</blockquote><blockquote>generate summaries instantly</blockquote><p>Not perfect.</p><p>But good enough for many use cases.</p><h3>3. No-code / simple automation tools</h3><p>Tools that connect workflows like:</p><p>AI agents are starting to replace this layer.</p><p>Instead of configuring flows manually:</p><blockquote><em>you describe what you want<br>the agent handles the execution</em></blockquote><h3>Where AI coding tools go further</h3><p>This is where it gets uncomfortable for SaaS founders.</p><p>Because now it’s not just usage being reduced.</p><p>It’s <strong>products being rebuilt on demand</strong>.</p><p>AI coding tools can now:</p><ul><li>generate internal tools</li><li>build simple dashboards</li><li>create lightweight apps</li><li>automate workflows</li></ul><p>That means:</p><p>Some SaaS products aren’t just being used less.</p><p>They’re being <strong>replaced entirely with custom-built alternatives</strong>.</p><h3>Real examples of what gets replaced</h3><p>Not theory this is where things are already happening.</p><h3>Example 1: Internal admin tools</h3><p>Instead of buying a SaaS product to:</p><p>Teams are building:</p><blockquote><em>lightweight internal tools using AI coding tools</em></blockquote><p>Faster than procurement.</p><p>More tailored.</p><h3>Example 2: Simple CRM-like workflows</h3><p>Smaller teams don’t always need full CRM systems.</p><p>Now they can:</p><ul><li>store data</li><li>query it</li><li>automate follow-ups</li></ul><p>Using a mix of:</p><ul><li>databases</li><li>AI</li><li>lightweight automation</li></ul><p>No full SaaS required.</p><h3>Example 3: Reporting dashboards</h3><p>Instead of:</p><ul><li>building dashboards</li><li>maintaining visualisations</li></ul><p>Teams are asking AI:</p><blockquote><em>“what happened this week?”<br>“why did sales drop?”</em></blockquote><p>And getting usable answers.</p><p>Not perfect.</p><p>But often enough.</p><h3>Why this hits small SaaS first</h3><p>Small SaaS products usually:</p><p>That’s exactly what AI tools + coding tools can replace.</p><p>If your product is:</p><p>Then AI doesn’t need to beat you.</p><p>It just needs to be “good enough.”</p><p>And once that threshold is crossed…</p><p>the question becomes:</p><blockquote><em>“Why are we paying for this?”</em></blockquote><h3>Why big SaaS is more protected</h3><p>Larger SaaS companies are different.</p><p>They:</p><ul><li>hold critical data</li><li>run core workflows</li><li>handle compliance</li><li>are deeply embedded</li></ul><p>AI tools don’t replace them.</p><p>They depend on them.</p><p>But even here, something is shifting.</p><p>Not replacement.</p><p><strong>Compression.</strong></p><p>Less:</p><ul><li>seat growth</li><li>feature expansion</li></ul><p>More:</p><ul><li>seat growth</li><li>feature expansion</li></ul><p>That changes growth even if products stay.</p><h3>The real shift</h3><p>This is the cleanest way to describe it:</p><blockquote><em>SaaS was built around humans using tools<br>AI is moving us toward systems executing work</em></blockquote><p>That changes where value sits.</p><h3>What I’d do differently</h3><p>If I was building today, I wouldn’t optimise for:</p><ul><li>UI</li><li>feature count</li><li>seat pricing</li></ul><p>I’d focus on:</p><ul><li><strong>being part of execution</strong></li><li><strong>working with AI agents, not competing with them</strong></li><li><strong>building something that can’t be easily rebuilt or bypassed</strong></li></ul><h3>Final thought</h3><p>This isn’t an apocalypse.</p><p>But it is a filter.</p><p>And AI tools especially coding tools are making one thing clear:</p><p>A lot of SaaS products weren’t essential.</p><p>They were just easier than building your own.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=08101e8c167b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Architecture Playbook That Survives Real Growth, Not Just Good Intentions]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/@duraidw/the-architecture-playbook-that-survives-real-growth-not-just-good-intentions-4c60fcbf4cf3?source=rss-aa10e04bba51------2"><img src="https://cdn-images-1.medium.com/max/740/1*7DXg12c3RCjpskI1xQQ0FA.jpeg" width="740"></a></p><p class="medium-feed-snippet">Date: November 30, 2025 | Author: Duraid Wadie | https://duraid-wadie.com/</p><p class="medium-feed-link"><a href="https://medium.com/@duraidw/the-architecture-playbook-that-survives-real-growth-not-just-good-intentions-4c60fcbf4cf3?source=rss-aa10e04bba51------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://medium.com/@duraidw/the-architecture-playbook-that-survives-real-growth-not-just-good-intentions-4c60fcbf4cf3?source=rss-aa10e04bba51------2</link>
            <guid isPermaLink="false">https://medium.com/p/4c60fcbf4cf3</guid>
            <category><![CDATA[architecture]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[desgin-patterns]]></category>
            <category><![CDATA[saas]]></category>
            <category><![CDATA[enterprise-architecture]]></category>
            <dc:creator><![CDATA[Duraid Wadie]]></dc:creator>
            <pubDate>Sun, 30 Nov 2025 22:29:33 GMT</pubDate>
            <atom:updated>2025-12-09T13:41:59.021Z</atom:updated>
        </item>
    </channel>
</rss>