<?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 Shobhit Srivastava on Medium]]></title>
        <description><![CDATA[Stories by Shobhit Srivastava on Medium]]></description>
        <link>https://medium.com/@srivastava.shobhit?source=rss-78bebc1b0b93------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*H2NAtQl-hcgCTAGm.</url>
            <title>Stories by Shobhit Srivastava on Medium</title>
            <link>https://medium.com/@srivastava.shobhit?source=rss-78bebc1b0b93------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 03:43:30 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@srivastava.shobhit/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[Beyond labor arbitrage: what changes for India’s software industry]]></title>
            <link>https://medium.com/@srivastava.shobhit/beyond-labor-arbitrage-what-changes-for-indias-software-industry-b3ee17dec55d?source=rss-78bebc1b0b93------2</link>
            <guid isPermaLink="false">https://medium.com/p/b3ee17dec55d</guid>
            <dc:creator><![CDATA[Shobhit Srivastava]]></dc:creator>
            <pubDate>Thu, 10 Sep 2026 15:02:20 GMT</pubDate>
            <atom:updated>2026-09-10T15:02:20.530Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vSv8sZH2uTG7GQu3FNVNPw.png" /></figure><p>For nearly three decades, India’s software model rested on a simple equation:</p><p><strong>Software needed lots of people. India could provide those people at a lower cost.</strong></p><p>AI-assisted development is starting to change that equation.</p><p>An engineer in Bengaluru has access to broadly the same coding agents as an engineer in London or New York. So India does not lose because AI is available elsewhere.</p><p>The bigger question is — <strong>What if the enterprise simply needs fewer engineers?</strong></p><p>If work that once required 100 people can be done by 40 people working with AI, finding the cheapest 100 is no longer the problem.</p><p><strong>Finding the right 40 is !</strong></p><p>And that has very different consequences for system integrators, GCCs and India’s existing technology workforce.</p><h3>1. System Integrators: what happens when more productivity means fewer billable people?</h3><p>For <strong>Indian Pure-Play (IPP) System Integrators</strong>, this is not just a technology shift. It goes to the heart of the business model.</p><p>For years, utilisation, offshore mix, pyramid management and headcount were closely connected to revenue.</p><p>Then AI arrives with some awkward good news — “<strong>Your engineers can do significantly more with fewer people”.</strong></p><p>Great for the client.</p><p>Potentially less exciting if your economics still depend heavily on engineering effort sold.</p><p>So the important question is not — <em>“How many employees have we trained on generative AI?”</em></p><p>It is — <strong>“What will customers pay us for when they need fewer of our people?”</strong></p><p>The answer has to move towards things that are <strong>harder to buy by the hour</strong>: industry expertise, difficult transformations, engineering IP, platforms, managed outcomes and accountability.</p><p><strong>Global System Integrators</strong> face a different version of the problem.</p><p>Their India centers are part of a global delivery network. If a piece of work needs 30 people instead of 150, there may be less reason to automatically move it to the largest offshore center.</p><p>Business proximity, regulation, specialist skills and product ownership start to matter more.</p><p>India centers may increasingly have to <strong>win the work on capability</strong>, rather than assume it will arrive because the cost equation points to India.</p><h3>2. The answer is not to make everyone an applied AI engineer</h3><p>This seems to be the industry’s current favorite answer — “Train everyone on generative AI. Hand out certifications. Create thousands of applied AI engineers.”</p><p>There is one small problem — <strong>The mathematics still doesn’t work.</strong></p><p>If AI reduces a body of work from 1,000 people to 500, giving all 1,000 an AI certification does not create 1,000 future roles.</p><p>And there is no reason everyone needs to become an applied AI engineer anyway.</p><p>Take a strong payments engineer. They understand settlement, reconciliation, fraud controls, transaction integrity and regulation.</p><p>Their best future may not be becoming another generic agent developer.</p><p>It may be becoming an exceptional <strong>payments engineer who knows how to use AI</strong>.</p><p>The same applies to security, data, reliability, quality and architecture.</p><p><strong>AI literacy becomes universal. Applied AI engineering remains a specialisation</strong>.</p><h3>3. But traditional engineering roles are not automatically safe either</h3><p>There is an equally comfortable counterargument:</p><p><em>“AI can write code, but we will always need architects, SREs, testers, data engineers and security engineers.”</em></p><p>Maybe !! But why assume AI stops at writing code?</p><p>With the right context and tools, LLMs and agents should increasingly be able to:</p><ul><li>analyse failure scenarios;</li><li>propose architectures;</li><li>trace dependencies;</li><li>generate test strategies;</li><li>detect security issues;</li><li>investigate production incidents;</li><li>reason about data quality.</li></ul><p>Even <strong>AI engineering itself will increasingly be AI-assisted</strong>.</p><p>So the future is probably <strong>not</strong> today’s team structure with everyone carrying an AI copilot.</p><p>It could mean <strong>far fewer specialists</strong>, with broader roles and much more specialist work performed by agents.</p><p>That is a much bigger workforce change.</p><h3>4. GCCs: the danger of oversimplifying the answer</h3><p>Many mature GCCs, particularly in banking, are already organized around products and capabilities.</p><p>Payments. Cards. Lending. Markets. Risk.</p><p>So the challenge is not another reorganization into product teams.</p><p>The bigger risk is assuming the future GCC looks like:</p><p><strong>Product teams + applied AI engineers + central AI platform.</strong></p><p>That is too neat.</p><p>The central AI platform is important. It can provide models, agent infrastructure, governance, evaluation and common tooling.</p><p>But the harder question for each product is:</p><p><strong>Which skills still need dedicated people, which skills can be combined, and which work can increasingly be delegated to agents?</strong></p><p>A payments team may today have separate developers, testers, architects, data engineers, reliability engineers and security specialists.</p><p>Over time, some of those boundaries may blur.</p><p>A smaller number of broader technologists may own the product while agents provide much of the specialist execution.</p><p>The answer is therefore neither:</p><p><strong>“Keep all today’s specialists.”</strong></p><p>nor:</p><p><strong>“Replace them with applied AI engineers.”</strong></p><p>The task is not to preserve today’s roles. It is to <strong>identify what still needs human ownership, and redesign the team around that.</strong></p><h3>5. There is one prerequisite: AI needs enterprise context</h3><p>For agents to move beyond coding, they need much more than source code and Jira tickets.</p><p>They need architecture, business rules, data definitions, policies, dependencies, controls, production telemetry and historical decisions.</p><p>This has an interesting consequence.</p><p>For years, enterprises could survive with outdated documentation because somebody usually knew how the system worked.</p><p>That becomes harder when the new team member asking the question is an AI agent.</p><p>So knowledge needs to become <strong>explicit, current and machine-readable</strong>.</p><p>What used to sit in people’s heads, old emails or scattered documents now needs to become part of the operating environment that both humans and AI can reliably use.</p><h3>6. So what happens to India’s existing software talent?</h3><p>This is the uncomfortable part.</p><p>Routine coding, basic testing, documentation, support and straightforward implementation will probably require fewer people.</p><p>But the impact may move further up the traditional pyramid as AI improves.</p><p>So simply moving everyone one level higher is not a strategy.</p><p><strong>The pyramid itself changes.</strong></p><p>The people who remain valuable are likely to have broader ownership.</p><p>They understand the business problem.</p><p>They understand enough of the system to make trade-offs.</p><p>They know what context AI needs.</p><p>They can use agents to perform work that previously required multiple specialists.</p><p>They can judge the output.</p><p><strong>And they own the consequence.</strong></p><p>For system integrators, this means figuring out how to <strong>grow without simply adding people</strong>.</p><p>For global system integrators, it means <strong>India centers competing increasingly on capability</strong> rather than only location economics.</p><p>For GCCs, it means redesigning product teams around <strong>human ownership plus machine execution</strong>, rather than simply adding an AI layer to today’s organisation.</p><p>And for India’s technology workforce, perhaps the career question becomes much simpler:</p><p><strong>Don’t just ask, “What new AI skill should I learn?”</strong></p><p>Instead ask — <strong>“How much more of the problem can I own if AI does more of the execution?”</strong></p><p>That may be where the software industry is heading.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b3ee17dec55d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Your AI Assistant Found an Answer. Can You Trust It?]]></title>
            <link>https://medium.com/@srivastava.shobhit/your-ai-assistant-found-an-answer-can-you-trust-it-f05952725448?source=rss-78bebc1b0b93------2</link>
            <guid isPermaLink="false">https://medium.com/p/f05952725448</guid>
            <dc:creator><![CDATA[Shobhit Srivastava]]></dc:creator>
            <pubDate>Fri, 28 Aug 2026 03:30:07 GMT</pubDate>
            <atom:updated>2026-08-28T03:30:07.854Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sS8mUsGPudcbodJkk_KJcw.png" /></figure><p>What it takes to move Enterprise RAG from a convincing pilot to dependable enterprise use</p><h3>The pilot is the easy part</h3><p>Most enterprise AI assistants look convincing in a demonstration.</p><p>A user asks a question. The system searches company documents. It produces a clear answer and cites a source.</p><p>This approach is often called retrieval-augmented generation, or RAG. In simple terms, the AI model searches enterprise information before it answers.</p><p>That sounds safe. However, it is not enough.</p><p>Consider an employee asking about travel reimbursement. The assistant finds a policy that was withdrawn six months ago. The wording closely matches the question. The answer is clear. The citation is real — The answer is also WRONG.</p><p>The system found <strong>relevant</strong> content. It did not establish that the content<strong> </strong>was<strong> current </strong>and<strong> approved</strong>.</p><p>This is the gap between a pilot and a production service. A <strong>pilot</strong> shows that the <strong>technology can answer.</strong> Production must prove that the organisation can <strong>trust the answer</strong>.</p><p>Our view is simple. A dependable enterprise AI assistant must pass four tests:</p><ol><li><strong>Relevance:</strong> Did it find the right information?</li><li><strong>Authority:</strong> Is that information approved and applicable?</li><li><strong>Evidence:</strong> Can a person verify the answer?</li><li><strong>Operability:</strong> Can the organisation run and change the service safely?</li></ol><p>A better model helps. Better search helps. Neither solves all four tests.</p><h3>1. Relevance: Did it find the right information?</h3><p>Enterprise information is rarely clean.</p><p>Repositories contain duplicate files, old versions, scanned pages and missing labels. The same term may mean different things across functions. A key condition may sit in an appendix, table or amendment.</p><p>A <strong>simple similarity search</strong> can therefore <strong>miss</strong> important context.</p><p>Take a customer onboarding team. An employee asks which documents are needed for a corporate customer. The answer may depend on the country, legal entity type, ownership structure and risk rating. A general know your customer, or KYC, policy may look relevant but still be incomplete for that customer.</p><p>The system must use more than similar wording. It may also need to consider:</p><ol><li>Exact policy names, codes and identifiers.</li><li>Business unit, country and customer type.</li><li>Document structure, tables and attachments.</li><li>The user’s role and access rights.</li><li>Links between a policy, its amendments and its exceptions.</li></ol><p>Language adds another challenge. A question may be asked in Arabic while the approved source is in English. The system must find the right source without changing the meaning of a legal or regulatory term. It must also cite the original text.</p><p>The executive test is not whether the <strong>assistant answers a curated set of questions</strong>. It is whether it works with the <strong>ambiguity</strong> found in real repositories.</p><h3>2. Authority: Is the information approved and applicable?</h3><p>Finding a <strong>related document</strong> does not make it <strong>authoritative</strong>.</p><p>A draft may be newer than the approved policy. A global policy may not apply in a particular region or country. A circular may have been replaced. A local rule may override a group standard.</p><p>The assistant needs clear rules for:</p><ol><li>Which repositories are trusted</li><li>Which versions are effective</li><li>Which approval states allow use</li><li>Which country or business rules apply</li><li>Which source takes precedence when documents conflict</li><li>Which questions require human approval</li></ol><p><strong>These decisions should not be left to the AI model</strong>.</p><p>A search index can find <strong>related content</strong>. It cannot decide that an approved policy overrides a draft. The model can explain a clause. It should not <strong>invent</strong> the organisation’s <strong>policy hierarchy</strong>.</p><p>Business rules and document controls must decide what the assistant may use.</p><p>The assistant must also be able to stop. If the approved sources are missing or in conflict, the right response may be: “<em>The available sources do not support a reliable answer. This request needs review.”<br></em>It is not a system failure, instead, it is a <strong>necessary control</strong>.</p><h3>3. Evidence: Can a person verify the answer?</h3><p>A link to a 200-page manual is not enough.</p><p>For important decisions, the user should be able to see what supports the answer. This may include:</p><ol><li>The document name and approved version</li><li>The relevant page, clause or table row</li><li>The exact passage used</li><li>Any rule applied after the search</li><li>Any conflicting source found</li><li>The reason the answer was withheld or escalated</li></ol><p>Consider a new regulatory circular. A useful assistant should do more than summarise it. It should identify the changed requirement, cite the relevant section and show which internal policies or controls may be affected.</p><p>This makes the output reviewable. It also makes errors easier to fix.</p><p>If a user rejects an answer, the team can check whether the issue came from the source, search, access rules, translation or model. Without this trail, teams often change the prompt or the model without finding the real cause.</p><h3>4. Operability: Can the organisation run it safely?</h3><p>The hardest questions often appear after the pilot.</p><ol><li>Who owns the source documents?</li><li>How are old versions removed or blocked?</li><li>How are access rights kept in sync?</li><li>Who investigates a wrong answer?</li><li>How are cost, speed and usage monitored?</li><li>What happens when a model or source system changes?</li><li>Who supports the service after the project team leaves?</li></ol><p>These are <strong>operating questions</strong>, not <strong>model questions</strong>.</p><p>Conversation history also needs control. An assistant should not treat an assumption from an earlier exchange as verified evidence. It should not reuse stale information after the source changes. It must not carry restricted content from one user or session into another.</p><p>The <strong>design</strong> should also <strong>preserve choice</strong>. Search, business rules and workflow logic <strong>should not be tied to one AI model</strong> or <strong>hosting platform</strong>. This allows the organisation to change models without rebuilding the full service.</p><p>The same applies to <strong>infrastructure</strong>. Public cloud may suit some workloads. Others may require sovereign cloud, private cloud or on-premises deployment. An on-premises option does not always require a large investment in computing capacity on day one. <strong>Capacity should grow with proven demand</strong>.</p><h3>Controls must sit across the full workflow</h3><p>Reliable systems apply controls at three points.</p><ol><li><strong>Before the search:</strong> Confirm the user’s identity, access rights and the type of request.</li><li><strong>While selecting evidence:</strong> Check the version, approval status, effective date, country and user entitlement.</li><li><strong>Before releasing the answer:</strong> Confirm that key claims have support. Check citations and restricted information. Escalate when required.</li></ol><p>These controls are not an <strong>outer safety layer</strong>. They are part of the application itself.</p><h3>A public service example</h3><p>Consider an assistant that answers questions about permit renewal.</p><p>A resident asks, “Which documents do I need?”</p><p>The answer may depend on location, permit type, applicant category and the date of the governing rule. Some information may come from published guidance. Other details may come from the applicant’s record.</p><p>A reliable design separates <strong>three responsibilities</strong>:</p><ol><li>The AI model <strong>explains</strong> the requirement in clear language.</li><li>Business rules <strong>determine</strong> which <strong>requirement</strong> applies.</li><li>The workflow <strong>records</strong> the request, evidence and any approval.</li></ol><p>This separation matters. The model helps people understand information. It does not quietly become the authority that sets eligibility or approves an action.</p><h3>What Leaders should require before scale</h3><h3>Define the boundary</h3><p>State what the assistant may <strong>answer, recommend or initiate</strong>.</p><p>An employee policy assistant carries a different risk from a system that recommends a compliance action or approves a customer request.</p><h3>Approve the sources and rules</h3><p>Name the <strong>trusted repositories</strong>. Define version, approval, precedence and effective-date rules.</p><p>Business, records, risk, security and technology leaders should agree on this model. The development team should not have to infer it.</p><h3>Test the failures</h3><p>Do not test only the easy questions. Include:</p><ol><li>An old document that is still searchable.</li><li>A draft that conflicts with an approved policy.</li><li>Missing or incomplete evidence.</li><li>A source the user is not allowed to access.</li><li>Questions in one language with sources in another.</li><li>A question that the assistant should refuse to answer.</li></ol><p>The ability to refuse or escalate may matter more than fluency.</p><h3>Assign owners before launch</h3><p>Name the <strong>owners</strong> for source quality, access control, answer policy, platform operations and incident handling.</p><p>Without clear ownership, old sources and unresolved exceptions will accumulate. Trust will decline long before the technology stops working.</p><h3>Reliability is engineered</h3><p><em>Do not judge an enterprise AI assistant by its best answer in a demonstration</em>.</p><p>Judge it by harder questions.</p><p>Did it use the right source? Was that source current and approved? Can the user verify the answer? Did the system stay within its authority? Can the organisation keep it reliable as policies, data and models change?</p><p>A better model may improve the writing. A better prompt may reduce some errors — neither replaces <strong>sound engineering</strong>.</p><h3><strong>A reliable enterprise AI assistant knows what to find, what to trust, how to prove its answer and when not to answer.</strong></h3><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f05952725448" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Real Cost of AI Coding Agents: When Faster Code Does Not Mean Better Delivery]]></title>
            <link>https://medium.com/@srivastava.shobhit/the-real-cost-of-ai-coding-agents-when-faster-code-does-not-mean-better-delivery-5fabc2180f11?source=rss-78bebc1b0b93------2</link>
            <guid isPermaLink="false">https://medium.com/p/5fabc2180f11</guid>
            <dc:creator><![CDATA[Shobhit Srivastava]]></dc:creator>
            <pubDate>Thu, 20 Aug 2026 12:51:00 GMT</pubDate>
            <atom:updated>2026-08-20T12:51:00.701Z</atom:updated>
            <content:encoded><![CDATA[<p><em>What our internal architecture experiments taught us about token cost, model choice and engineering return in AI-led software delivery</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BjU8iUljf8Lr2TVZUhl8MA.png" /></figure><h3>The cost appeared after the code</h3><p>Consider a small change to a customer onboarding application. A new validation rule must be added. The requirement and acceptance tests are clear.</p><p>An AI coding agent looks like a good fit. It reads the relevant files, proposes the change, updates the tests and prepares the code for review.</p><p>The first attempt fails a test. The agent reads more files, tries another approach and checks additional dependencies. The final code works.</p><p>The change looks successful. But why did it consume much more than a similar change? Did the additional activity improve the accepted result?</p><p>We encountered this question during our internal architecture experiments for AI-led software delivery. Our first design treated token consumption mainly as a reporting concern. We expected teams to review model usage after the work, much like cloud spend.</p><p>That assumption did not survive the complete delivery flow.</p><p>The individual coding steps worked. The harder problem was connecting consumption to an authorised feature, the right class of model and a useful engineering result.</p><p>Our current view is simple: token cost cannot sit outside the software delivery design. It must be controlled where the work happens.</p><h3>What the experiment showed</h3><p>● Token use varied because agents reread files, explored alternatives, diagnosed failures and restarted work.</p><p>● One class of model did not suit every engineering activity or risk level.</p><p>● A monthly total showed cost, but not which feature, team or activity created it.</p><p>● A rigid cap could stop useful work. An open budget could fund an unproductive loop.</p><p>● Return became visible only when cost was compared with accepted work and a delivery baseline.</p><h3>What we tried</h3><p>We built a controlled path for a coding agent to work on bounded application changes. It combined code generation with architecture checks, testing and traceability.</p><p>We captured the model used, the context supplied and the consumption created during each run. The work used a controlled repository and simulated delivery conditions. It was an internal architecture experiment, not a client production deployment.</p><p>We began with a familiar model: give teams access, use a common coding path and review unusual spend later.</p><p>But agentic coding does not consume tokens like a fixed licence. An agent may reread files, load unnecessary context, generate alternatives and restart after failures.</p><p>Two similar tasks can therefore create very different consumption. This may be justified. It may also signal weak context, a poor model-task fit or an unproductive loop.</p><p>Here, tokenomics means the operating economics of that consumption: what caused it, which model handled it, what result it produced and when the activity should stop.</p><h3>What we learnt</h3><h3>1. Consumption without purpose is only an activity measure</h3><p>Our first design showed model usage by team and period. It could not explain which approved feature caused it. Rising tokens could mean productive adoption, unnecessarily broad context or repeated failures.</p><p>The same issue has appeared at a much larger scale. Uber reportedly exhausted its annual AI budget by April 2026. Its leadership questioned whether rising consumption could be connected to more useful features. The issue was the missing link between activity and output. <a href="https://www.forbes.com/sites/janakirammsv/2026/05/17/uber-burns-its-2026-ai-budget-in-four-months-on-claude-code/">Source: Forbes</a></p><p>We required each run to carry a feature identifier, an authorised purpose and an expected output. Consumption could then be attributed to a specific change.</p><h3>2. The largest waste often began before generation</h3><p>We initially focused on generation. The build showed that input context could be just as important.</p><p>Too many files made every later step heavier. Failed attempts added earlier reasoning, test output and alternative code to another cycle.</p><p>Poor context also created more chances to follow an irrelevant path. We narrowed the initial context by task. The agent could request more information, but the expansion became visible and attributable.</p><h3>3. One model and one ceiling were both too blunt</h3><p>Strict token limits stopped runaway consumption, but treated unlike work as if it were the same.</p><p>A model generating unit tests for a known service does not need the same reasoning capacity as one assessing a change to a shared identity service. A local refactor is different from tracing an intermittent failure across several applications.</p><p>This led us to a tiered design. Routine, bounded work could use a smaller and faster model. Ambiguous or cross-system work could move to a stronger model. Higher-risk changes still required human approval, regardless of the model.</p><p>Each tier received an expected consumption range and an exception path. A run could stop, request approval or move to another model or method.</p><p>We are also testing alternative models against the current default for each type of task. The comparison considers accepted output, review effort, delivery speed, failures and total cost. Token price alone does not determine which model is more economical.</p><h3>4. Cost only made sense beside evidence and a baseline</h3><p>The final code file did not prove value. We needed passed tests, architecture compliance, traceability and evidence that the accepted change improved on the previous way of working.</p><p>For the baseline, we grouped completed changes into comparable categories such as defect fixes, minor enhancements, refactoring and cross-system changes. We then used recent work from the same codebase to establish the median engineering effort, time to an accepted change, review effort, rework and defects for each category.</p><p>The start and end points had to remain consistent. Elapsed time began when work started on an accepted task and ended when the change met its acceptance criteria and was ready for release. Time formally paused for unrelated reasons was excluded.</p><p>Elapsed time mattered because faster code generation did not always mean faster delivery. A model could save coding time while creating additional review, security checks or rework. Engineering effort showed whether human capacity had been released. Elapsed time showed whether the organisation received the outcome sooner.</p><p>Where no meaningful historical comparison existed, we used a controlled sample of similar tasks with the same acceptance tests. We did not use lines of code or story points as proof of value.</p><p>Tokens per engineer were easy to report, but weak for decisions. Cost per accepted engineering outcome was more useful.</p><p>For example, a model may save an engineer 90 minutes of coding but add two hours of review and correction. The code appeared faster. The accepted change did not.</p><p>The return test must include licences, tokens, integration, controls, review and rework. That total must be compared with time released, shorter delivery time, fewer defects, lower risk or greater engineering capacity.</p><p>If consumption rises while accepted changes, delivery time, review effort and quality remain flat, the coding model is only adding cost. Generated lines of code, prompts and tokens are not returns.</p><h3>What changed in practice</h3><p><strong>We assumed monthly usage would explain cost.</strong> It did not identify the feature or activity that caused it. We attached every run to an authorised feature and expected output.</p><p><strong>We assumed generation was the main cost driver.</strong> Broad context, retries and restarts also created substantial use. We limited the initial context and made expansion visible.</p><p><strong>We assumed one model and one cap would simplify control.</strong> Different activities needed different capabilities, risk controls and consumption ranges. We tiered models by task and introduced rerouting and approval paths.</p><p><strong>We assumed more AI activity suggested more output.</strong> High consumption did not prove quality, speed or completion. We compared the full cost with an accepted outcome and its delivery baseline.</p><h3>The operating pattern that emerged</h3><p>The pattern we currently trust has four parts: define, bound, observe and verify.</p><p><strong>Define the work.</strong> Every run starts with an approved feature, a clear purpose and a required result.</p><p><strong>Bound the run.</strong> The task is routed to an appropriate model tier, context limit and expected consumption range.</p><p><strong>Observe the activity.</strong> The delivery path records model use, context growth, retries, restarts and cost while the work is happening.</p><p><strong>Verify the result.</strong> Consumption is reviewed beside tests, controls, review effort, acceptance status and the pre-AI baseline.</p><p>We placed these controls where the agent created the risk and cost. The central dashboard was no longer the main control.</p><h3>What technology leaders should test next</h3><h3>Establish the baseline first</h3><p>Select one category of software change. Use recent, comparable work to establish its median engineering effort, time to acceptance, review effort, rework, defects and acceptance rate.</p><h3>Tier by activity and risk</h3><p>Separate bounded work, complex reasoning and high-risk changes. Give each category a default model, consumption range and escalation path.</p><h3>Test alternatives and measure the return</h3><p>Run an alternative model on a controlled sample. Compare full cost, accepted output, time to acceptance, review effort and quality. Token use alone is not productivity.</p><h3>Where our thinking has landed — for now</h3><p>In our internal build, token consumption stopped being a finance report and became part of the engineering control system.</p><p>Some difficult changes will justify more model work. The reason, limit and result should remain visible.</p><p>We are still refining the tiers, expected ranges and model comparison thresholds. We are also testing when a run should stop, request approval or change its method.</p><p>The central lesson is already clear:</p><p><strong>Do not reward the tokens consumed. Control for the engineering result produced.</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5fabc2180f11" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Beyond Prompting: Field Notes on Governing AI Coding Agents at Scale]]></title>
            <link>https://medium.com/@srivastava.shobhit/beyond-prompting-field-notes-on-governing-ai-coding-agents-at-scale-369cbec9cfee?source=rss-78bebc1b0b93------2</link>
            <guid isPermaLink="false">https://medium.com/p/369cbec9cfee</guid>
            <dc:creator><![CDATA[Shobhit Srivastava]]></dc:creator>
            <pubDate>Tue, 11 Aug 2026 05:32:46 GMT</pubDate>
            <atom:updated>2026-08-11T05:32:46.256Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZzDsoo4y8BdQ7nlJuqqajw.png" /></figure><p>Generating code with AI is trivial. Governing <strong>what was generated </strong>— <strong>and why</strong> — is where our early deployment pipelines broke.</p><p>When we set up our first internal pilot to automate the path from requirement to production using autonomous coding agents, the early demos were impressive. An agent given a clear prompt could emit application code, unit tests, and pipeline manifests in under three minutes.</p><p>Then we increased its <strong>operational autonomy</strong> — we gave agents broader repository access, allowing them to trace dependencies, make architectural choices, and run automated retry loops to fix broken builds. <em>That is when our engineering reality diverged from vendor promises</em>.</p><p>In our test runs, <strong>unapproved feature additions slipped past review</strong>, context windows <strong>silently ingested sensitive local configuration files</strong>, and <strong>single debugging loops burned through compute budgets in minutes</strong>.</p><p><em>Generating software became cheap. Governing how our engineering teams generated it became our primary platform challenge</em>.</p><p>Here are <strong>five field note</strong>s from the <strong>architecture changes</strong> we had to build around our AI agents.</p><h3><strong>1. We Stopped Relying on Prompts to Fix Ambiguous Input</strong></h3><p>In our early iterations, when an agent’s code output drifted from expected behavior, our engineers naturally tried to <strong>patch the prompt </strong>— adding <em>longer context windows</em>, <em>explicit architectural rules</em>, and <em>negative constraints</em>.</p><p>It failed to scale.</p><p>When human engineers encounter <strong>missing edge cases in a ticket</strong>, they <strong>check with a lead</strong>. When an <strong>agent encounters ambiguity</strong>, it fills the gap via <strong>inference</strong>. In one of our pilot runs, when asked to “add an invoice viewer,” the agent helpfully inferred and generated code for invoice downloads, dispute triggers, and billing address edits. <strong>It worked, but it quietly introduced unapproved API endpoints and authorization risks</strong>.</p><p><strong>What we engineered:</strong> We <em>stopped treating prompts as requirements</em>. We introduced a pre-processing step that converts incoming tickets into machine-readable feature specifications (<strong>Spec-as-Code</strong>). The workflow validates this specification against our core business rules <em>before</em> any code generation starts.</p><p>If the spec is ambiguous, execution halts before a single token is consumed.</p><h3><strong>2. We Converted Architectural Principles into Pipeline Checks</strong></h3><p>During week four of our rollout, <strong>two different developers ran agents on similar microservices</strong>. Both outputs passed their unit tests. However, one agent used an <em>unapproved third-party logging library</em>, while the other invented a <em>completely custom folder structure</em>.</p><p><strong>Static confluence pages</strong> and <strong>PDF design guides</strong> do not work for agents. An agent will either miss the document entirely or interpret a “strongly recommended” pattern as optional. Catching these deviations during manual code review destroyed our delivery velocity.</p><p><strong>What we engineered:</strong> We separated intent from enterprise constraints:</p><ul><li><strong>Feature Specifications:</strong> Tell the agent <strong><em>what</em></strong> business outcome to build.</li><li><strong>Enterprise Blueprints:</strong> Set the non-negotiable hard boundaries of <strong><em>where</em></strong><em> </em>and<em> </em><strong><em>how</em></strong> it may be built.</li></ul><p>We translated <strong>our architectural standards</strong> into <strong>automated linter rules</strong>, <strong>policy-as-code checks</strong>, and <strong>repository templates</strong>. If an agent attempts to introduce an <strong>unauthorized dependency</strong> or <strong>alter a core pattern</strong>, the <em>build pipeline fails immediately with a policy violation</em>.</p><h3><strong>3. We Moved Security Controls Directly into the Model Execution Path</strong></h3><p>Giving an agent <strong>repository access is necessary for complex refactoring</strong>, but it created an <strong>immediate data isolation risk</strong> in our environment. During an early defect-resolution test, an agent tracing a bug automatically <strong>scanned local test fixtures</strong>, <strong>system logs</strong>, and <strong>environment variables</strong> — <strong>pulling sensitive customer payload data directly into the model context </strong>window.</p><p><strong>Written security policies</strong> like “<em>do not paste confidential data into prompts</em>” provide <strong>zero protection</strong> at runtime.</p><p><strong>What we engineered:</strong> We deployed an <strong>inline security proxy</strong> directly between <strong>our developer workstations/CI runners</strong> and the <strong>LLM endpoints</strong>.</p><p>Every context payload is inspected in real time. PII, internal IP, and API credentials are masked or blocked before the payload ever leaves our network boundaries.</p><h3><strong>4. We Set Token Circuit Breakers to Stop Runaway Agent Loops</strong></h3><p>When we first embarked on our journey of embedding autonomous agents into our SDLC workflows, we t<strong>racked AI consumption through monthly usage reports</strong>. That approach broke as soon as we <strong>moved from passive code-completion assistants</strong> to <strong>fully autonomous agents</strong> executing multi-step engineering tasks.</p><p>Once an agent has the agency to run builds, diagnose failures, and attempt fixes, <strong>it can easily get stuck in an infinite loop</strong>. <em>In one overnight trial, an agent encountered a failing integration test, modified the code, re-ran the suite, failed again, and repeated the cycle — executing 42 recursive loops, reading massive context files on every attempt, and burning through compute spend for a minor bug fix</em>.</p><p>This isn’t an internal anomaly. As engineering orgs scale agentic adoption, token consumption rapidly decouples from shipped value — a <strong><em>reality Uber faced in 2026 when their engineering team exhausted their entire annual AI budget in the first quarter alone</em></strong> as autonomous coding agents spread across thousands of developers.</p><p><strong>What we engineered:</strong> We stopped viewing token spend as a <strong>post-hoc finance metric</strong> and built <strong>runtime circuit breakers</strong> into our agent platform:</p><ul><li><strong>Context Budgets:</strong> We scope file access tightly <strong>per task</strong> rather than dumping whole repositories into context.</li><li><strong>Loop Limits:</strong> We set a hard ceiling (<em>typically 3–5 iterations</em>) on <strong>autonomous retries</strong> before requiring human intervention.</li><li><strong>Feature Attribution:</strong> Every API call must be <strong>tagged with a valid feature ID</strong>, ticket number, and developer identity account.</li></ul><p>If an agent <strong>exceeds its execution boundary</strong>, the platform triggers an <strong>inline kill switch</strong> and escalates the task to a human engineer.</p><h3><strong>5. We Force Agents to Generate Evidence, Not Just Code</strong></h3><p>As generation velocity increased, our senior engineers became a bottleneck. They were drowning in <strong>massive</strong>, <strong>multi-file pull requests</strong>, spending hours trying to <strong>reverse-engineer</strong> <em>why</em> an agent c<strong>hose a specific algorithm or database query pattern</strong>.</p><p>Working code without context isn’t an asset; it’s instant technical debt.</p><p><strong>What we engineered:</strong> We updated our <strong>build definition</strong> so an agent cannot submit a Pull Request unless it emits an <strong>Evidence Package</strong> alongside the raw code.</p><p>Human review shifted from <strong>scrutinising raw code syntax</strong> to evaluating the <strong>generated Architecture Decision Record</strong> (ADR) and <strong>policy compliance</strong>. If the rationale behind a design choice is sound, approving the PR takes minutes.</p><h3><strong>What Our Iterations Taught Us</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PPPPFOgfxOKeKFPvPBW2Ww.png" /></figure><h3><strong>How We Apply This Across Project Archetypes</strong></h3><p>We quickly realised that applying a <strong>single agent workflow</strong> across <strong>all codebase types</strong> was a mistake. Our field notes show t<strong>hree distinct operational profiles</strong>:</p><ul><li><strong>Greenfield Projects:</strong> Easiest path. Agents start within pre-approved enterprise scaffolds. The <em>primary guardrail needed here is stopping scope creep</em>.</li><li><strong>Brownfield Codebases:</strong> High risk of unintended side effects. <em>We limit context access strictly to the target module and its direct dependencies to prevent agents from refactoring adjacent code</em>.</li><li><strong>Legacy Modernization:</strong> Directly asking an agent to translate legacy code (e.g., COBOL or Java 8) to modern languages <strong>just reproduces 15-year-old technical debt in a new syntax</strong>. We use agents first to <strong>extract business logic into a specification</strong>, review that spec, and then <strong>generate clean target code</strong> against <strong>modern architectural blueprints</strong>.</li></ul><h3><strong>Final Note</strong></h3><p>The goal of our platform team is <strong>not to slow down AI adoption</strong>, but to make sure <strong>we don’t scale an unmonitored development pattern</strong>.</p><p>Before we expand agent autonomy in any internal team, we look for <strong>three hard operational signals</strong>:</p><ol><li><strong>Intent Validation:</strong> Can the platform halt unapproved feature generation <em>before</em> code is written?</li><li><strong>Runtime Control:</strong> Can our proxies kill a runaway loop or data leak <em>while it is happening</em>?</li><li><strong>Audit Traceability:</strong> Does the output contain the decision history needed for a new engineer to maintain it two years from now?</li></ol><h3>The strongest AI models will not make your engineering organisation elite. The control plane you build around them will.</h3><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=369cbec9cfee" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Your Enterprise Does Not Need 50 AI Use Cases. It Needs Eight Repeatable AI Capabilities]]></title>
            <link>https://medium.com/@srivastava.shobhit/your-enterprise-does-not-need-50-ai-use-cases-it-needs-eight-repeatable-ai-capabilities-8acd83b149fe?source=rss-78bebc1b0b93------2</link>
            <guid isPermaLink="false">https://medium.com/p/8acd83b149fe</guid>
            <dc:creator><![CDATA[Shobhit Srivastava]]></dc:creator>
            <pubDate>Wed, 05 Aug 2026 03:08:36 GMT</pubDate>
            <atom:updated>2026-08-05T03:18:34.023Z</atom:updated>
            <content:encoded><![CDATA[<h3><strong>Why the tenth AI solution should cost less than the first</strong></h3><p>Most enterprises do not have a shortage of AI ideas. They have a <strong>shortage of AI solutions</strong> that <strong>move from pilot to production</strong> — and make the next solution <strong>faster</strong>, <strong>safer</strong> and <strong>less expensive</strong> to build.</p><p><em>A contract assistant, customer-service copilot, project-risk advisor and regulatory-change solution may be sponsored by different business units. They may also be built by different teams, using different technologies, controls and delivery methods</em>.</p><p>The first pilot may be delivered quickly. But as the portfolio grows, the <strong>enterprise often pays for the same engineering several times</strong>.</p><p><em>Information retrieval is rebuilt. Documents are parsed again. Scoring logic is implemented differently. Integrations are recreated. Security and approval controls vary. Each solution becomes tied to its original model, vendor and architecture</em>.</p><p>The result is a <strong>collection of isolated AI applications</strong> rather than a <strong>scalable enterprise capability</strong>.</p><p><strong>The business problems may be different; the underlying engineering often is not</strong><em>.</em></p><h3><strong>Look beyond the business labels</strong></h3><p>A new AI use case can appear highly specialised when described in the language of a particular industry or function. However, once that language is removed, the underlying workflow is often familiar:</p><ul><li>Find the right information.</li><li>Convert it into a useful structure.</li><li>Judge what matters.</li><li>Create an output.</li><li>Reason across the implications.</li><li>Retain decisions and changing context.</li><li>Take an approved action.</li><li>Run calculations or code safely.</li></ul><p>This leads to <strong>eight</strong> repeatable AI capabilities:</p><p><strong>Find; Structure ; Judge ; Create ; Reason ; Evolve ; Act ; Execute</strong></p><p>These capabilities cover much of the <strong>journey from fragmented information</strong> to <strong>governed action</strong>.</p><p>These can be grouped into <strong>three stages</strong>.</p><p><strong>1.</strong> <strong>Understand the information -&gt; Find. Structure. Judge</strong></p><p><strong>2.</strong> <strong>Form a view -&gt; Create. Reason</strong></p><p><strong>3.</strong> <strong>Complete the work safely -&gt;Evolve. Act. Execute</strong></p><p>This also provides a practical architecture principle — “<strong>Understand first. Form a view second. Act third”</strong></p><p>Obviously, not every solution needs all eight capabilities. They are <strong>reusable building blocks</strong>, not a <strong>compulsory sequence</strong>.</p><h3><strong>The eight repeatable capabilities</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/904/1*6PAETdJbzV70b9Z5jEvsJA.png" /></figure><p>Each of the above capability must operate within <strong>clear engineering</strong> and <strong>governance controls</strong>.</p><h3><strong>An illustrative business workflow (a regulatory change) shows how the capabilities work together</strong></h3><p><em>Consider a new regulation that affects several business units, policies, processes and systems</em>.</p><p>The leadership team wants to know:</p><ul><li>What has changed?</li><li>Where is the enterprise exposed?</li><li>What must happen next?</li><li>Who is accountable?</li><li>How quickly must the organisation respond?</li></ul><p>A governed AI workflow could:</p><ol><li><strong>Find</strong> the regulation, guidance notes, internal policies, contracts and earlier decisions.</li><li><strong>Structure</strong> the obligations, deadlines, affected entities and required evidence.</li><li><strong>Judge</strong> which functions are affected and rank issues by urgency and impact.</li><li><strong>Create</strong> executive summaries, policy updates and communication drafts.</li><li><strong>Reason</strong> across the legal, operational, financial and customer consequences.</li><li><strong>Evolve</strong> the assessment as evidence, interpretations and decisions change.</li><li><strong>Act</strong> by creating tasks, assigning owners and requesting approvals.</li><li><strong>Execute</strong> exposure calculations and response scenarios in a controlled workspace.</li></ol><p>The use case (<em>regulatory process</em>) is <strong>specific to the enterprise</strong> — the <strong>underlying capabilities are not</strong>.</p><p><em>The same extraction capability can support contract review. The same evaluation capability can assess suppliers. The same grounded generation capability can produce an operational briefing or board summary; </em><strong><em>this is where reuse truly begins to create value</em></strong>.</p><h3><strong>‘Engineer once’, where the ‘requirement repeats’</strong></h3><p><em>Business workflows should retain the rules, context and decisions that make them distinctive</em>, the <em>common engineering beneath them should not be rebuilt for every use case</em>.</p><p><strong>Keep the business logic distinctive. Engineer the common capabilities for reuse.</strong></p><p><em>This means building retrieval, extraction, evaluation, generation, workflow integration and controlled execution as governed components that can be tested and applied across multiple solutions.</em></p><p><strong>Reuse becomes valuable only when it works in production</strong> — it must reduce delivery effort, strengthen controls and make later implementations easier to operate.</p><p><strong>What the enterprise gains from reuse</strong></p><p>A reusable engineering approach can provide four practical advantages.</p><ol><li><strong>Faster delivery</strong></li></ol><p>Subsequent workflows can use capabilities that were already built and tested. <strong>Teams do not need to begin every implementation from an empty repository</strong>.</p><p><strong>2. More consistent control</strong></p><p>Security, evidence management, approvals, testing and auditability do not need to be redesigned for every use case. <strong>The same controls can be applied across multiple solutions and strengthened over time</strong>.</p><p><strong>3. Greater deployment choice</strong></p><p>Solutions can run in the enterprise’s preferred public cloud, private cloud, on-premises environment or sovereign deployment. <strong>A change in deployment environment should not require the business workflow to be rebuilt</strong>.</p><p><strong>4. Reduced technology dependence</strong></p><p>Models and providers can be changed without rewriting the complete solution, provided the replacement passes the required quality, safety and performance tests. <strong>The business workflow should not be permanently tied to one model or one platform</strong>.</p><h3><strong>This is a delivery architecture, not another platform programme</strong></h3><p>The <strong>eight capabilities</strong> do not imply that every <strong>enterprise should build a large AI platform</strong> before <strong>delivering any business solution</strong>. That would <strong>recreate the same problem</strong> in a different form.</p><p>The capabilities should be <strong>built and strengthened through real workflows</strong>. The first workflow <strong>proves</strong> that the <strong>capability works</strong>. The second <strong>tests</strong> whether it <strong>can be reused</strong>. The third <strong>shows</strong> whether the <strong>approach can scale</strong>.</p><p>The aim is <strong>not to build eight finished services in isolation</strong>. Instead, it is to <strong>build only what is needed</strong>, <strong>prove it in production</strong> and <strong>reuse it where the requirement genuinely repeats</strong>.</p><h3><strong>Start with business value</strong></h3><p>AI should not be prioritised simply because a use case is technically possible. It should materially improve at least one of three outcomes:</p><ul><li><strong>Business performance</strong>, including revenue, cost, risk or delivery</li><li>Customer or colleague <strong>experience</strong></li><li><strong>Productivity</strong> and <strong>decision quality</strong></li></ul><p>If a proposed use case <strong>does not</strong> improve one of these outcomes, it should not be an AI priority. A better starting point is to select <strong>two or three high-value workflows</strong> with <strong>common engineering needs</strong>. For example:</p><ul><li>Contract review</li><li>Regulatory-change assessment</li><li>Supplier qualification</li></ul><p>These are <strong>different business processes</strong>. But they may <strong>share the same need for</strong>:</p><ul><li>Information retrieval</li><li>Document extraction</li><li>Evaluation and scoring</li><li>Content generation</li><li>Approval workflows</li><li>System integration</li><li>Controlled execution</li></ul><p>The enterprise can <strong>reuse these common capabilities</strong> while <strong>preserving the distinct business logic of each process</strong>.</p><h3><strong>Reuse must be measured</strong></h3><p>It is not enough to <strong>describe a capability as reusable</strong>. The enterprise <strong>should be able to show that reuse improves delivery</strong>. Useful measures include:</p><ul><li>Delivery time for later workflows.</li><li>Reduction in duplicated engineering.</li><li>Percentage of tested components reused.</li><li>Consistency of controls.</li><li>Cost per implementation.</li><li>Time required to replace a model.</li><li>Production reliability.</li><li>Adoption and business outcomes.</li></ul><p>The objective is not to claim that the capabilities are reusable. It is to <strong>prove that each implementation makes the next one better</strong>.</p><h3><strong>The main question is not only: “Which model should we choose?”</strong></h3><p>Model selection matters. But enterprise value does not come from access to a model alone.</p><p>It comes from <strong>engineering that model into real data</strong>, <strong>applications</strong>, <strong>controls</strong> and <strong>operating processes</strong>. The more useful questions for enterprise leaders are:</p><ul><li>Are different teams rebuilding the same AI capabilities?</li><li>Are evidence, security and approval controls consistent?</li><li>Which high-value opportunities share common engineering needs?</li><li>Can a model or provider be changed without rebuilding the workflow?</li><li>Who will own each solution after the pilot?</li><li>What should remain deterministic rather than being delegated to a model?</li><li>How will value, adoption and reuse be measured?</li><li>Can the solution be deployed and operated within the enterprise’s security and infrastructure constraints?</li></ul><p>These questions move the discussion from <strong>isolated experimentation</strong> to <strong>production engineering</strong>.</p><h3><strong>Make every successful implementation improve the next one</strong></h3><p>Enterprise AI will not scale by <strong>treating every use case as a separate invention</strong>. It will scale when each successful implementation makes the next one:</p><ul><li>Faster to deliver.</li><li>Safer to operate.</li><li>Easier to govern.</li><li>Less dependent on one technology provider.</li><li>Clearer in its business value.</li></ul><p>That should be the practical test of enterprise AI maturity</p><h3>“<strong>Your tenth AI solution should not cost, take and risk as much as your first”.</strong></h3><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8acd83b149fe" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The AI use case with the highest ROI may still be the wrong one to build first]]></title>
            <link>https://medium.com/@srivastava.shobhit/the-ai-use-case-with-the-highest-roi-may-still-be-the-wrong-one-to-build-first-1de17ca4716a?source=rss-78bebc1b0b93------2</link>
            <guid isPermaLink="false">https://medium.com/p/1de17ca4716a</guid>
            <dc:creator><![CDATA[Shobhit Srivastava]]></dc:creator>
            <pubDate>Tue, 28 Jul 2026 13:57:44 GMT</pubDate>
            <atom:updated>2026-07-28T14:13:41.485Z</atom:updated>
            <content:encoded><![CDATA[<p><em>The right first use case creates value now, builds capabilities for the next wave and helps the AI platform move towards paying for itself.</em></p><p>In more than two decades of professional experience, I’ve taken part in many <strong>prioritization workshops</strong>. The topic changes — growth, transformation or technology — but the situation is usually the same.</p><p>There are too many <strong>good ideas</strong>, <strong>not enough money</strong> and <strong>several people convinced</strong> that their initiative should come first.</p><p>Not surprisingly, nobody puts their own idea in the <strong>bottom-left</strong> corner of the prioritization matrix.</p><p>I’ve seen this discussion play out more times than I can remember. Exactly, the same thing is now happening with <strong>Enterprise AI</strong>.</p><p>Business teams suggest customer-service copilots, contract analysis, automated reporting, employee assistants and, of course, several chatbots.</p><p>The ideas are scored for <strong>business impact</strong> and <strong>ease of delivery</strong>. The ones in the top-right corner become the priorities.</p><p>There is nothing wrong with this approach. But <strong>it produces a ranked list — not an AI portfolio</strong>. But that is usually where the problem starts.</p><p><strong>This usual approach ignores how AI economics work </strong>because it treats <strong>every use case as a separate investment</strong>.</p><p>In practice, many AI use cases need the <strong>same building blocks</strong>:</p><ul><li>Access to enterprise data and documents</li><li>Reliable information retrieval</li><li>Data extraction and classification</li><li>Quality checks and evaluation</li><li>Security and access controls</li><li>Connections to enterprise systems</li><li>Monitoring and governance</li></ul><p>If every use case builds these capabilities again, the enterprise is not scaling AI — instead, i<strong>t is rebuilding the same foundations under different project names</strong>.</p><p>When discussing <strong>AI priorities with clients</strong>, I therefore introduce a second question.</p><p>The <strong>first</strong> is the familiar one: “Which use case creates the most business value?” The <strong>second</strong> is: “Which use case will make the next five faster and cheaper to deliver?”</p><p>This sounds like a small change. In practice, it changes most of the conversation. It moves the focus from <strong>ranking individual ideas</strong> to building a <strong>capability-led sequence of investments</strong>.</p><p>The approach that I use has <strong>three</strong> moves: <strong>Qualify</strong> the use cases, <strong>Select</strong> a few anchors and <strong>Build</strong> the portfolio in waves.</p><h3><strong>Move 1: Qualify use cases before ranking them</strong></h3><p>The first step is to <strong>remove use cases</strong> that are not ready for near-term investment.</p><p><strong>Business Value</strong> and <strong>Readiness</strong> work as two simple gates.</p><p>A use case should enter the near-term portfolio only if it has:</p><ul><li>A measurable business outcome</li><li>Enough users, transactions or financial impact to matter</li><li>A business owner accountable for adoption</li><li>Usable data</li><li>A realistic delivery path</li><li>A safe operating model</li></ul><p>“Improve customer experience” is <strong>not a measurable outcome</strong>. “Reduce customer-request resolution time from 18 minutes to 12 minutes” is.</p><p>The same discipline applies to productivity.</p><p>Saving ten minutes may help an employee complete one more routine task. Useful, yes. But unless those minutes add up across a high-volume process, they are unlikely to create meaningful capacity or reduce cost.</p><p>A surprising number of otherwise attractive use cases struggle at this first step</p><p><strong>Readiness also includes risk.</strong></p><p>An AI system may assist a person, recommend a decision or act autonomously. These require very different levels of confidence and control.</p><p>A weak email draft is annoying. A wrong contract recommendation is more serious. An AI system approving the wrong payment tends to create a sudden rise in senior-management attention.</p><p>A <strong>high-value use case</strong> can start with <strong>human oversight</strong>. More <strong>automation can follow </strong>once there is evidence that the <strong>system works reliably.</strong></p><p>Qualifying use cases <strong>prevents attractive but vague ideas</strong> from taking over the roadmap.<strong> It still does not tell us what to build first.</strong></p><h3><strong>Move 2: Select a few “anchor” use cases</strong></h3><p>An anchor use-case does two jobs:</p><p>First, it creates a <strong>meaningful</strong> and <strong>measurable business result</strong>. Second, it <strong>establishes capabilities that several other use cases will reuse</strong>.</p><p>Consider supplier invoice processing — its <strong>direct value</strong> may come from reducing manual data entry, speeding up processing and lowering errors.</p><p>But delivering it may also establish a <strong>reusable document-parsing capability</strong> — reading PDFs and scans, classifying documents, extracting fields and tables, validating results and routing exceptions.</p><p>The <strong>same capability</strong> could later support <strong>purchase orders</strong>, <strong>contracts</strong>, <strong>onboarding forms</strong>, <strong>claims</strong> and <strong>compliance documents</strong>. This creates two forms of return:</p><ul><li><strong>Direct return:</strong> the value created by the anchor use case</li><li><strong>Reuse return:</strong> the cost and time avoided when later use cases consume the same capabilities</li></ul><p>In client discussions, I insist that the <strong>reuse return</strong> is linked to named f<strong>ollower use cases.</strong></p><p>Saying that a capability “<em>could be reused across the enterprise</em>” is easy. Most platform business cases contain a sentence like that. I tend to be quite strict on this point — <strong>“someone may reuse it someday” is not a portfolio.</strong></p><p>The aim is to <strong>select a small number of anchor use cases</strong> that <strong>collectively</strong> <strong>create value</strong> and <strong>cover the capabilities</strong> needed by the next wave<strong>.</strong></p><h3><strong>Move 3: Build and fund the portfolio in waves</strong></h3><p>Once the anchor use cases are selected, the roadmap can be built around them.</p><p><strong>Wave 1: Prove value and establish the foundations</strong></p><p>Deliver the anchor use cases and only the shared capabilities they genuinely need. <strong>Build what the anchors need now</strong> — not everything the platform may possibly need three years from now.</p><p>Despite running the risk of being the “bad guy” I strictly advise against<strong> building a large, general-purpose AI platform</strong> in anticipation of <strong>future demand</strong>.</p><p><em>That is exactly how a two-year platform programme begins, usually with benefits scheduled for “next year”</em>.</p><p><strong>Wave 2: Reuse before expanding</strong></p><p>Deliver the <strong>follower use cases</strong> that can reuse the capabilities created in Wave 1.</p><p>The <strong>cost and delivery time of these applications should be lower</strong>. This is where reuse must move from an architecture slide into actual numbers. If they are not, the <strong>supposed reuse</strong> needs to be questioned.</p><p><strong>Later waves: Increase complexity and automation</strong></p><p>Add use cases that require <strong>more data</strong>, <strong>deeper integration</strong> or <strong>greater autonomy</strong> after the core capabilities and controls have been road-tested in production. Needless to add, <strong>funding should also move in waves</strong>.</p><p><strong>Further investment</strong> should depend on evidence of:</p><ul><li>User adoption</li><li>Realized business value</li><li>Capability reuse</li><li>Falling delivery cost</li><li>Acceptable operational performance</li></ul><p>This turns the <strong>roadmap into a series of investment decisions</strong> rather than a <strong>long list of promises</strong>.</p><h3><strong>Cost-neutrality is a portfolio outcome</strong></h3><p><strong>Not every AI use case needs to fund itself independently</strong>.</p><p>The first anchor may carry much of the cost of building document processing, retrieval, evaluation and governance. Later applications should benefit from that investment. <strong>The better goal is cost-neutrality across the portfolio</strong>.</p><p>Over an agreed period, the value created by the use cases should cover the cost of building and running the shared AI platform. Not from day one, obviously. But there should be a date attached to it.</p><p>This requires two connected views:</p><ul><li>At the <strong>use-case level</strong>, track <strong>adoption</strong>, realized <strong>benefit</strong> and incremental <strong>cost</strong>.</li><li>At the platform level, track <strong>shared costs</strong>, <strong>reuse</strong> and whether each new use case is <strong>becoming cheaper to deliver</strong>.</li></ul><p>The ROI of the first use case matters. But the <strong>cost and speed of delivering the fifth may tell us more about whether the strategy is working</strong>.</p><p><em>If the fifth use case costs as much as the first, the enterprise probably hasn’t built a reusable platform. It has built the first use case five times</em>.</p><p><strong>The answer is a sequence, not a ranking</strong></p><p>The leadership discussion should come down to three questions:</p><ol><li>Which use cases can <strong>create measurable value</strong> now?</li><li>Which of them will <strong>build capabilities for a committed second wave</strong>?</li><li>In what sequence can the <strong>portfolio move the platform towards cost-neutrality</strong>?</li></ol><p>This may put a <strong>moderately valuable</strong> but <strong>highly reusable use case</strong> ahead of a <strong>larger, isolated </strong>opportunity.</p><p><strong>That is not a compromise on ROI. It is a more complete view of it. </strong>For me, that is the real test of the first use case.</p><p><em>T</em><strong><em>he best first AI use case is not simply the one with the highest standalone return. It is the one that creates value now, leaves something useful behind and makes everything that follows easier to deliver</em></strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1de17ca4716a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Future-Proofing IT: A strategic framework for methodically addressing Technical Debt, Architectural…]]></title>
            <link>https://medium.com/@srivastava.shobhit/future-proofing-it-a-strategic-framework-for-methodically-addressing-technical-debt-architectural-11a55097ed2a?source=rss-78bebc1b0b93------2</link>
            <guid isPermaLink="false">https://medium.com/p/11a55097ed2a</guid>
            <category><![CDATA[technical-debt]]></category>
            <category><![CDATA[tech-modernization]]></category>
            <category><![CDATA[it-modernization-strategy]]></category>
            <category><![CDATA[it-strategy-and-planning]]></category>
            <dc:creator><![CDATA[Shobhit Srivastava]]></dc:creator>
            <pubDate>Sat, 19 Apr 2025 11:25:56 GMT</pubDate>
            <atom:updated>2025-04-19T11:25:56.866Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/626/1*yzAvKHPqqyomXp552bcdIg.jpeg" /></figure><h3><strong>Future-Proofing IT: A strategic framework for methodically addressing Technical Debt, Architectural Debt, and Technical Obsolescence</strong></h3><p>In today’s dynamic digital economy, IT ecosystems are both a strategic enabler and a potential bottleneck. The three silent and often overlooked challenges: <strong>Technical debt</strong>, <strong>Architectural debt</strong>, and <strong>Technical obsolescence</strong> erode an organization’s ability to innovate, scale, and comply with regulatory mandates. These inefficiencies, if left unaddressed, amplify operational costs, increase cybersecurity vulnerabilities, and constrain business agility.</p><p><strong>These challenges demand a strategic response. </strong>Addressing them is not just a technology only problem, — it is a Organizational leadership imperative. This requires aligning technical health with business priorities, regulatory requirements, and long-term growth objectives.</p><p>This blog introduces a comprehensive framework to:</p><p>1. <strong>Diagnose and prioritize systemic inefficiencies</strong> across the IT landscape</p><p>2. Enable <strong>Transformation </strong>through <strong>targeted modernization</strong>, <strong>automation</strong>, and <strong>innovation </strong>initiatives.</p><p>3. Establish strategic <strong>Governance framework</strong> to ensure <strong>alignment</strong>, <strong>adaptability</strong>, and <strong>accountability</strong>.</p><p>Integrating IT health into business strategy primes IT ecosystems for the future, strengthens resilience, and opens new growth opportunities.</p><p><strong>A Strategic Framework for Change</strong></p><p>This framework is structured into three key pillars, each designed to lead transformational change while addressing the unique characteristics of Technical debt, Architectural debt, and Technical obsolescence:</p><p>1. <strong>Strategic Diagnosis and Prioritization</strong>: Identify and prioritize inefficiencies based on business-critical <strong>risks</strong> and <strong>ROI</strong> analysis.</p><p>2. <strong>Transformation Enablement</strong>: Develop tailored strategies to <strong>modernize</strong>, <strong>automate</strong>, and <strong>innovate</strong>.</p><p>3. <strong>Strategic Governance</strong>: Establish governance structures that ensure <strong>alignment</strong>, <strong>adaptability</strong>, and <strong>accountability</strong>.</p><p><strong>Pillar 1: Strategic Diagnosis and Prioritization</strong></p><p>The first step in addressing systemic inefficiencies and risks, is to <strong>diagnose</strong> the current state of the IT ecosystem and then <strong>prioritize</strong> interventions using robust ROI analysis to highlight strategic value. This <strong>data-driven</strong> approach secures critical <strong>buy</strong>-<strong>in</strong> from <strong>business</strong> executives by clearly linking <strong>IT improvements</strong> to tangible <strong>business</strong> <strong>benefits</strong>.</p><p>1. <strong>Record and Classify systemic challenges</strong></p><p>Establish a comprehensive <strong>diagnostic layer</strong> to capture both the “stock” (the current state) and the “flow” (ongoing dynamics) of technical challenges. This dual approach provides a <strong>factual</strong> <strong>baseline</strong> and continuous oversight for effective modernization.</p><p><strong>For Stock Data:</strong></p><p>· <strong>Static Code Analysis:</strong> Leverage tools like SonarQube to snapshot code health, identifying legacy code smells, duplications, and technical debt zones.</p><p>· <strong>Asset Inventory:</strong> Use configuration management databases (<strong>CMDB</strong>) and IT asset management solutions to record the status of hardware, software, and supporting components (including their version, support state, and EOL status).</p><p>· <strong>Architectural Modelling:</strong> Conduct in-depth architectural reviews and maintain system diagrams to document <strong>monolithic</strong> structures, integration <strong>chokepoints</strong>, and <strong>outdated</strong> design patterns.</p><p>· <strong>Documentation Audits:</strong> Regularly assess technical documentation, design blueprints, and compliance records to capture existing process and <strong>policy</strong> <strong>gaps</strong>.</p><p><strong>For Flow Data:</strong></p><p>· <strong>Runtime Monitoring: </strong>Data from Application Performance Monitoring (APM) systems and log aggregation tools (e.g., ELK Stack) that continuously capture system performance <strong>metrics</strong>, <strong>errors</strong>, and integration <strong>failures</strong>.</p><p>· <strong>DevOps Pipeline Metrics:</strong> Data from continuous integration processes to track build <strong>failures</strong>, test <strong>flakiness</strong>, and deployment <strong>delays</strong>.</p><p>· <strong>Incident Management:</strong> IT service management (ITSM) platforms to record real-time <strong>events</strong>, outage <strong>frequencies</strong>, and incident resolution <strong>times</strong>.</p><p>· <strong>User Feedback Loops:</strong> Periodic surveys and developer feedback channels to capture qualitative data on ongoing system usability and performance issues.</p><p><strong>Classification:</strong></p><p>· <strong>Technical Debt:</strong> Inefficient or <strong>outdated</strong> code — whether from deprecated frameworks, un-refactored modules, or quick-fix workarounds — slows down development and increases maintenance efforts. This debt makes it harder to deploy new features rapidly and may lead to repeated bug fixes, ultimately driving up operational costs.</p><p>· <strong>Architectural Debt:</strong> <strong>Rigid</strong> or <strong>fragmented</strong> system structures — such as monolithic designs or siloed integrations — limit scalability and hinder integration with modern solutions. This debt often stems from <strong>piecemeal</strong> <strong>upgrades</strong> and <strong>legacy</strong> <strong>design</strong> decisions, making the transition to modular, cloud-native, or microservices architectures that support agile business growth challenging.</p><p>· <strong>Technical Obsolescence:</strong> Reliance on <strong>outdated</strong> <strong>components</strong> — legacy hardware, unsupported operating systems, aging software, outdated middleware, obsolete third-party libraries, and OEM products no longer receiving updates — places the IT ecosystem at significant risk. These components often lack essential patches and support, leading to security vulnerabilities, performance degradation, and compliance challenges.</p><p><strong>2. Assess Strategic Impact</strong></p><p>A <strong>data-driven view</strong> of the IT ecosystem shows how technical challenges shape key <strong>business outcomes</strong>. This approach focuses on three strategic areas:</p><p>· <strong>Business Agility:</strong> Technical debt <strong>slows development</strong> and <strong>delays feature rollouts</strong>. Tracking metrics like development cycle times, bug resolution rates, and feature deployment delays highlights how coding inefficiencies restrict the ability to innovate and respond swiftly to market demands.</p><p>· <strong>Operational Resilience:</strong> Architectural debt <strong>limits scalability</strong> and <strong>complicates integrations</strong>. Monitoring system uptime, performance benchmarks, and integration error rates reveals how legacy architectures create operational bottlenecks, increasing the risks to business continuity and scalability.</p><p>· <strong>Regulatory &amp; Cybersecurity Posture:</strong> Technical obsolescence <strong>exposes</strong> the ecosystem to significant <strong>security</strong> and <strong>compliance</strong> <strong>risks</strong>. Reviewing asset life cycles, patch update frequencies, and vulnerability scan results provides a clear picture of how reliance on legacy components jeopardizes security and regulatory adherence.</p><p><strong>3. Prioritization Framework</strong></p><p>A robust, forecast-based model forms the foundation for comparing modernization initiatives well before full-scale implementation. Leverage advanced scenario analyses to project the benefits of addressing key technical challenges:</p><p>· <strong>Efficiency Gains:</strong> Forecasted improvements in deployment speed, reduced MTTR, and enhanced system performance underscore the benefits of refactoring legacy code and streamlining complex architectures.</p><p>· <strong>Cost Savings:</strong> Projected drops in maintenance overhead, vendor fees, and downtime penalties capture the financial gains from modernizing legacy systems and replacing outdated components.</p><p>· <strong>Risk Mitigation Savings:</strong> Predicted savings from avoiding cybersecurity breaches, regulatory fines, and system failures highlight the value of updating unsupported hardware, software, middleware, and third-party libraries.</p><p>· <strong>Business Enablement:</strong> Anticipated revenue growth and improved customer satisfaction from faster feature rollouts illustrate the strategic dividends of IT modernization.</p><p>Building on these forecasted outcomes, a <strong>value-based prioritization</strong> <strong>framework</strong> ranks initiatives using:</p><p>· <strong>ROI Analysis</strong>: Historical <strong>cost</strong> data, <strong>simulation models</strong>, and forecasted revenue <strong>gains</strong> used to rank projects over a 3–5 year horizon, employing techniques such as Monte Carlo simulations and sensitivity analysis.</p><p>· <strong>Strategic Urgency:</strong> Asset lifecycle data and compliance assessments pinpoint systems nearing end-of-life or at risk of security breaches, with <strong>predictive</strong> analytics flagging vulnerable areas.</p><p>· <strong>Business Impact:</strong> <strong>Revenue models</strong> and customer usage trends help prioritize revenue-generating and customer-facing systems, with dashboards clearly mapping performance to business outcomes.</p><p>· <strong>Transformation Complexity:</strong> <strong>Resource</strong> metrics, project <strong>benchmarks</strong>, and <strong>estimation</strong> methods (e.g., story points or T-shirt sizing) quantify the effort required for modernization against its expected benefits.</p><p>This data-driven framework directly links forecasted efficiency gains, cost savings, risk mitigation, and business enablement with core IT challenges, ensuring that modernization investments align with strategic business objectives and deliver measurable results.</p><p><strong>Pillar 2: Transformation Enablement</strong></p><p>Cultivate an engineering-driven culture to accelerate IT transformation, using team topologies to structure and empower teams while resolving inefficiencies through automation, modernization, and innovation.</p><p><strong>Targeted Roadmaps:</strong> Remediation plans grounded in real operational needs and strategic business objectives:</p><p>· <strong>Technical Debt:</strong> A <strong>disciplined</strong> approach to code improvement. Empower engineering teams to schedule regular, incremental refactoring within agile sprints and measure quality gains by tracking metrics such as cyclomatic complexity and code maintainability.</p><p>· <strong>Architectural Debt:</strong> <strong>Phased</strong> migration plan to shift from monolithic systems to modular, strategic target state (for e.g. service-oriented) architecture to ensure scalability and seamless component interconnectivity.</p><p>· <strong>Technical Obsolescence:</strong> <strong>Systematic upgrade schedule</strong> for aging hardware and software. Asset management systems to monitor end-of-life timelines and compliance risks, coupled with application of a risk-based strategy to replace critical legacy components with modern, supportable alternatives — aligning refresh cycles with regulatory and security mandates.</p><p><strong>Automation &amp; Continuous Feedback:</strong> Remediation activities integrated into existing operational workflows. DevOps pipelines to subsume automate testing, deployment, and monitoring. Use of real-time dashboards and periodic review cycles to capture performance data and iterate on remediation efforts, ensure alignment of all initiatives with strategic targets.</p><p><strong>Pillar 3: Strategic governance and Operational resilience</strong></p><p><strong>Governance and Resilience: Foundations for Technical Health</strong></p><p>Governance ensures strategic oversight, while resilience enables adaptability and continuous improvement.</p><p>1. <strong>Governance Model</strong></p><p>A governance framework empowers senior executives to oversee technical health initiatives while delegating operational responsibilities.</p><p><strong>Roles and Responsibilities:</strong></p><p>· <strong>CIOs and Senior Executives:</strong> Align initiatives with business objectives, secure funding, and communicate progress to stakeholders. Provide strategic oversight.</p><p>· <strong>Enterprise Architects:</strong> Define scalable, resilient architectures and guide transitions from legacy systems to modular frameworks.</p><p>· <strong>Engineering Leaders:</strong> Drive technical debt reduction, ensure maintainability through automation, and track KPIs.</p><p>· <strong>Compliance Officers:</strong> Ensure regulatory adherence and audit readiness. Collaborate with teams to mitigate risks tied to aging systems.</p><p>· <strong>IT Operations Leaders:</strong> Manage lifecycle processes, automate patching and upgrades, and track system health in real-time.</p><p><strong>Real-Time Dashboards:</strong> Centralized dashboards, with intuitive interface and drill-down capabilities, should be built aligned with CIO objectives (for eg metrics related to overarching business outcomes, such as revenue, agility, or regulatory compliance, data complemented with actionable insights etc). They ensure transparency, accountability, and alignment by consolidating metrics like system scalability, compliance status, and technical debt reduction, enabling role-specific visibility without operational micromanagement.</p><p><strong>2. Building Resilience</strong></p><p>Resilience ensures agility in the face of challenges and opportunities.</p><p><strong>Feedback Loops:</strong> Conduct regular reviews using dashboards to monitor metrics such as defect density, system performance, and compliance. Use insights to recalibrate priorities.</p><p><strong>Escalation Protocols:</strong> Establish workflows for addressing high-priority risks, compliance issues, or unresolved gaps. Empower steering committees to act swiftly on escalated matters.</p><p><strong>Continuous Improvement:</strong> Leverage retrospective findings and dashboard trends to refine governance and adapt to evolving business and regulatory needs.</p><p>By embedding real-time dashboards into governance and resilience strategies, organizations achieve transparent oversight, measurable accountability, and seamless alignment with strategic objectives, ensuring sustainable modernization outcomes.</p><p><strong>Conclusion</strong></p><p>Addressing Technical debt, Architectural debt, and Technical obsolescence is not just about <strong>fixing inefficiencies</strong> — it is about <strong>enabling transformation, resilience, and growth.</strong> By adopting this framework, Technology leaders can <strong>future-proof</strong> their IT ecosystems, <strong>align</strong> them with business priorities, and <strong>unlock</strong> their full potential.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=11a55097ed2a" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>