<?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 Khushi Shah on Medium]]></title>
        <description><![CDATA[Stories by Khushi Shah on Medium]]></description>
        <link>https://medium.com/@khushijigenshah?source=rss-ec7f37f4433f------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*0QeNTmiyfC_xHb09</url>
            <title>Stories by Khushi Shah on Medium</title>
            <link>https://medium.com/@khushijigenshah?source=rss-ec7f37f4433f------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 16:18:21 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@khushijigenshah/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[Why Prompts Don’t Stop AI Agents From Leaking Secrets (And What Does)]]></title>
            <link>https://medium.com/@khushijigenshah/why-prompts-dont-stop-ai-agents-from-leaking-secrets-and-what-does-88f15456805d?source=rss-ec7f37f4433f------2</link>
            <guid isPermaLink="false">https://medium.com/p/88f15456805d</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[no-code]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Khushi Shah]]></dc:creator>
            <pubDate>Tue, 17 Nov 2026 10:46:10 GMT</pubDate>
            <atom:updated>2026-11-17T10:46:10.622Z</atom:updated>
            <content:encoded><![CDATA[<p>Here’s my short answer: you stop an AI agent from leaking a secret by making sure it never has the secret to leak. Not by asking nicely in the system prompt, and not by hoping the model “knows better.”</p><p>Reading through public incident write-ups and security research, I keep seeing the same pattern, and I think it’s the most common mistake in agent security. A team gives an agent access to a repo, a few APIs, and a long prompt that says something like “never share credentials.” Everyone relaxes. Then a .env file ends up in a commit, or a token shows up in a log, and the conversation turns to &quot;but we told it not to.&quot;</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Lew9uAnLMbecHkqFeQrvCQ.png" /></figure><h3>Why a prompt instruction feels like a control</h3><p>I think there’s a psychological reason this keeps happening. Written rules feel like policy. We’re used to rules working on people: you tell a new hire “don’t share the password,” and they mostly don’t. So we write the same sentence for the agent and feel covered.</p><p>But a prompt is something a model weighs. It isn’t something the system enforces. <a href="https://owasp.org/www-project-top-10-for-large-language-model-applications/assets/PDF/OWASP-Top-10-for-LLMs-2023-v09.pdf">OWASP’s research on LLM application risks</a> lays out how crafted inputs, including instructions buried in a web page or document the agent reads, can steer a model into unintended actions and sensitive information disclosure. If the secret is within reach, a polite instruction is a thin barrier.</p><h3>The data says this is already happening</h3><p>I don’t love leaning on statistics, but one set is hard to ignore. GitGuardian’s <a href="https://blog.gitguardian.com/the-state-of-secrets-sprawl-2026/">State of Secrets Sprawl 2026</a> found 28.65 million new hardcoded secrets in public GitHub commits in 2025, up 34% year over year. Commits assisted by Claude Code leaked secrets at 3.2%, compared with a 1.5% baseline.</p><p>What I appreciate is that GitGuardian doesn’t treat that as “AI is bad at security.” AI-assisted changes are bigger and faster, so there’s simply more surface area for a credential to slip through. My read: AI didn’t invent the problem, it sped up the old habits.</p><h3>What I’d actually do, in order</h3><p>If I were setting this up from scratch, this is the sequence I’d follow.</p><p><strong>Give every agent its own identity.</strong> Shared service accounts are the first thing I’d remove. If five agents share one account, you can’t tell them apart in an audit and one leak exposes all five.</p><p><strong>Scope credentials tightly.</strong> Only the resources, environment, and permissions the task needs, with short-lived tokens where possible. A front-end bug fix has no reason to touch production data.</p><p><strong>Keep secrets out of anything the agent can read.</strong> That means prompts, workspace files, shell history, and retrieval indexes. Use a secrets manager, and scan the workspace before a run.</p><p><strong>Inject credentials at runtime, outside the agent’s view.</strong> The agent asks for “the payments API,” a gateway attaches the token, and the agent only ever sees the result. This is the single biggest shift in thinking for me: the safest secret is one the agent never saw.</p><p><strong>Limit where data can go.</strong> An egress allowlist, blocked cloud metadata endpoints, and rate limits. If something does leak into context, it still can’t leave.</p><p><strong>Filter outputs and logs, then monitor.</strong> Redact anything that looks like a credential, plant a few honeytokens (fake credentials that alert you when used), and rotate quickly after any exposure. That last part matters more than people think. GitGuardian’s <a href="https://dev.to/gitguardian/the-state-of-secrets-sprawl-2026-ai-service-leaks-surge-81-and-29m-secrets-hit-public-github-2bgj">retest of older leaks</a> found more than 64% of valid secrets from earlier years were still valid in January 2026.</p><h3>Why I think people are drifting toward structured platforms</h3><p>This part is opinion, so take it as that. I think the move toward multi-agent platforms is less about speed than about legibility. When one agent does everything in one sprawling session, it’s hard to say what it saw or touched. When the work is split into defined roles and stages, you get natural checkpoints to review, log, and restrict.</p><p>That’s part of why I find platforms in the <a href="https://8080.ai/?utm_source=medium&amp;utm_medium=content&amp;utm_campaign=manual&amp;utm_content=article">8080.ai</a> category interesting. Its own <a href="https://dev.to/8080_ai/7-ai-trends-shaping-2026-how-agentic-workflows-are-changing-the-way-we-build-software-5e7m">write-up on agentic workflows</a> says every agent action is logged and traceable, and the platform plans architecture before code gets generated. That doesn’t replace a secrets manager or an egress policy, and I wouldn’t claim it does. But it gives you a structure where those controls have somewhere to attach.</p><h3>The objection I hear most: “Doesn’t this slow us down?”</h3><p>It’s a fair question, and I think the honest answer is: a little at the start, and much less than the alternative later. Setting up separate identities and a runtime injection layer takes real effort. But that effort is paid once. The cost of the other path, rotating every credential an agent might have touched after an incident, tends to show up at the worst possible time.</p><p>I also think the speed argument is slightly backwards. Teams adopt agents to move faster. A leaked production key turns a fast week into a very slow one. The controls aren’t the opposite of velocity. They’re what lets you keep it.</p><h3>What I’d check on a Monday morning</h3><p>If I only had an hour, I wouldn’t start with tooling. I’d start with three questions:</p><ul><li>Can I list every agent that has credentials, and who owns each one?</li><li>If I searched the workspace an agent runs in, would I find a key, a token, or a .env file?</li><li>If one of those credentials leaked today, how fast could I revoke it, and would I even know?</li></ul><p>If any of those answers is “I’m not sure,” that’s the work. It’s not glamorous, but it’s where most of the risk lives.</p><h3>Where I think this is heading</h3><p>My bet is that “agent security” stops being its own category and becomes ordinary engineering hygiene, the way HTTPS and password managers did. The teams that get there first will be the ones that stopped treating the agent as a trusted colleague and started treating it as what it is: a very capable process that should be given exactly the access its job needs, and no more.</p><h3>The part I won’t automate</h3><p>I’d keep a person in charge of the judgment calls: what each agent can reach, what goes on the allowlist, which actions need sign-off, and what happens after a suspected leak. Machines can enforce the rules. People should decide what the rules are.</p><p>If you take one thing from this, make it this: stop writing better instructions and start shrinking what the agent can reach. A well-worded prompt is nice to have. A secret the agent can’t see is a control.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=88f15456805d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Enterprise AI Agent Governance: My Take on Why Ownership Beats Policy]]></title>
            <link>https://medium.com/@khushijigenshah/enterprise-ai-agent-governance-my-take-on-why-ownership-beats-policy-c4f73ce64fed?source=rss-ec7f37f4433f------2</link>
            <guid isPermaLink="false">https://medium.com/p/c4f73ce64fed</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[no-code]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Khushi Shah]]></dc:creator>
            <pubDate>Mon, 16 Nov 2026 10:48:45 GMT</pubDate>
            <atom:updated>2026-11-16T10:48:45.946Z</atom:updated>
            <content:encoded><![CDATA[<p>If you ask me how to govern AI agents in an enterprise, my short answer is this: give every agent a named human owner, limit what it can touch, check it while it runs, and keep a record. The policy document matters, but it is the least interesting part.</p><p>I keep coming back to that because of a pattern I see in how companies talk about agents. The conversation almost always starts with policy: acceptable use, approved models, review boards. Those are fine. But when I read what organizations actually discover once they go looking, the problem is rarely a missing policy. It is that nobody knew the agent was there.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cztlW_edK9uw2ha6MVr8VQ.png" /></figure><h3>The number that changed how I think about this</h3><p>A Cloud Security Alliance survey of 418 IT and security professionals, commissioned by Token Security, found that <a href="https://www.token.security/blog/csa-token-report-highlights-ai-agent-security-risks">68% of organizations believed they had strong visibility into their AI agents, while 82% had found at least one agent or workflow built without their security, IT, or governance teams knowing</a>. You can read the full <a href="https://cloudsecurityalliance.org/artifacts/autonomous-but-not-controlled-ai-agent-incidents-now-common-in-enterprises">Autonomous but Not Controlled report</a> yourself. It is vendor-sponsored, so I read it as directional rather than gospel, but the gap it describes matches what many practitioners say.</p><p>What I find telling is not the 82%. It is the 68% next to it. Most leaders were not careless. They believed they had control, because they had governance for users, applications, and infrastructure and assumed it would stretch to agents. It mostly does not, because an agent is not quite any of those things. It is software that makes choices, using access a person handed it.</p><h3>Why I think ownership beats policy</h3><p>A policy tells people what should happen. An owner makes sure it does.</p><p>When I look at how agents sneak past governance, it is almost never because someone defied a rule. It is because someone wired an assistant into a SaaS automation or a shared drive for a perfectly good reason, and the thing never got registered. No registry entry means no owner. No owner means no one reviewing its permissions, and no one noticing when the project ended but the agent kept running.</p><p>That last part is the one I think is underrated. In the same survey, <a href="https://www.token.security/blog/csa-token-report-highlights-ai-agent-security-risks">only 21% of organizations had a formal process for decommissioning agents</a>. Creating agents is exciting, so it gets process. Retiring them is boring, so it does not. But an agent that was low risk in January can be holding production access by December if nobody ever closed the loop.</p><p>So if I were setting priorities, I would put them in this order.</p><p><strong>First, a living inventory.</strong> Not a spreadsheet someone updates once a quarter, but a registry that records each agent’s purpose, owner, environment, data and tool access, and dependencies. Agents come and go with developer workflows, so anything static goes stale fast.</p><p><strong>Second, named accountability.</strong> A business owner for the outcome, an operational owner for the agent, someone responsible for its access and risk, and someone who can approve exceptions. If nobody will claim an agent, that is a finding by itself.</p><p><strong>Third, tiers instead of blanket rules.</strong> An agent that summarizes internal documents and an agent that issues refunds should not face the same process. Classify by autonomy, data sensitivity, business impact, and how reversible the actions are, then size the controls to match.</p><p><strong>Fourth, least privilege and least agency.</strong> Give agents the narrowest access that works, time-bound credentials, and read-only by default. Then also limit what they can decide alone.</p><p><strong>Fifth, enforcement in the loop.</strong> Rules on paper do not stop an agent mid-action. Tool-level checks, policy engines, and automatic pause or redirect do.</p><p><strong>Sixth, a human for the consequential stuff.</strong> Money moving, data being deleted or changed, messages going to customers, anything touching production. These are the actions where a person should say yes first.</p><p><strong>Seventh, evidence.</strong> Logs, traces across steps, alerts on anomalies, and a retention habit, so that when something goes wrong you can reconstruct what happened.</p><h3>The part about human approval that I think people get wrong</h3><p>Everyone agrees that a human should approve the risky stuff. The disagreement, in my experience of reading how teams describe their setups, is about what “risky” means and where the approval sits.</p><p>The common mistake is putting the approval at the very end. An agent does an hour of work, produces something, and a person is asked to sign off on the result. By then the reviewer is looking at a finished pile of output with no real way to judge what went into it, so the approval becomes a rubber stamp. People click yes because rejecting means redoing everything.</p><p>I would much rather see the gate placed early, at the point where a person is approving a plan, a specification, or a set of permissions. That is a real decision. It is also much easier to reverse. And it keeps the approver in a role that humans are actually good at, which is judging intent, rather than the role they are bad at, which is inspecting thousands of lines of machine output for subtle mistakes.</p><p>There is also a human side to it. Reviewers get tired. If every action needs a click, people stop reading. Tiering helps here, because it lets you save the real scrutiny for the handful of actions that deserve it and let low-risk work flow through with logging.</p><h3>Why I think this topic is blowing up now</h3><p>It is worth asking why agent governance became a boardroom topic so quickly. My theory is that it comes down to how delegation feels.</p><p>When you hand a task to a person, you have a sense of who they are, what they can see, and what they will do if something goes wrong. When you hand a task to an agent, that intuition is missing, but the sense of being “in control” carries over anyway. The 68% figure above is basically that feeling, measured. People felt in control because the early agents were small and easy to reason about.</p><p>Then the count grew, the permissions piled up, and the intuition stopped matching reality. I think the current wave of interest is a lot of leaders noticing that mismatch at roughly the same time, and looking for ways to get a grounded picture back.</p><h3>Where I think the industry is heading</h3><p>My honest read is that teams are drifting toward environments where the governance is part of the workflow rather than a layer added afterward. Retrofitting control onto a sprawl of agents is painful, and people who have been through it tend to prefer not repeating it.</p><p>You can see that instinct in how some agentic platforms are built. <a href="https://8080.ai/?utm_source=medium&amp;utm_medium=content&amp;utm_campaign=manual&amp;utm_content=article">8080.ai</a>, for example, describes a process where <a href="https://8080.ai/">requirements, user flows, and the architecture plan each wait for a person to approve them before agents write code, and later changes to requirements arrive as a diff the person accepts or rejects</a>. I am obviously not a neutral voice on that one, which is why I flagged my role at the top. But the idea behind it is what I care about: the human decision belongs at the point where a wrong call is least costly.</p><p>Other tools approach this differently. Replit and Lovable focus on fast app building, and frameworks like LangGraph and CrewAI give engineering teams building blocks for their own agent systems. The right choice depends on how much control you need and how much you want to assemble yourself. Whichever you pick, test it against the seven priorities above.</p><h3>What I would tell a CIO on Monday</h3><p>Do not start with the policy. Start by finding out what you have. Ask each team a plain question: which agents, assistants, or automated workflows are running in your area, and who owns each one? The answers will be incomplete, and that incompleteness is exactly the information you need.</p><p>Then pick one high-risk agent, the kind that can move money or change data, and walk it through the whole model: owner, tier, permissions, runtime checks, approval gate, logs. One agent done properly teaches more than a hundred pages of policy.</p><p>Governance is not what slows AI adoption down. Not knowing what you have is.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c4f73ce64fed" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Can a Web Page Hijack Your AI Agent? My Take on Indirect Prompt Injection]]></title>
            <link>https://medium.com/@khushijigenshah/can-a-web-page-hijack-your-ai-agent-my-take-on-indirect-prompt-injection-1efd1d0833a2?source=rss-ec7f37f4433f------2</link>
            <guid isPermaLink="false">https://medium.com/p/1efd1d0833a2</guid>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[no-code]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Khushi Shah]]></dc:creator>
            <pubDate>Fri, 06 Nov 2026 10:34:08 GMT</pubDate>
            <atom:updated>2026-11-06T10:34:08.446Z</atom:updated>
            <content:encoded><![CDATA[<p>Yes, a web page can hijack an AI agent. If your agent reads a page, an email or a document, and that content contains text phrased like an instruction, the agent may treat it as one. That is indirect prompt injection, and the part I think people underestimate is how ordinary the entry point is. It isn’t a hacker typing into your chat window. It is a support ticket, a scraped article, a PDF someone attached.</p><p>I’ll be upfront about my own bias here: when I first started reading about this, I assumed the answer was better prompting. Write a firmer system prompt, tell the model to ignore anything suspicious, move on. The more I read, the less I believe that, and the guidance from the people who do this for a living backs it up.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DCtCsCxvYsqLStZsfIGZ4A.png" /></figure><h3>What does “tool output is untrusted input” actually mean?</h3><p>It means the moment your agent calls a tool, whatever comes back is text from the outside world. Your agent doesn’t automatically know who wrote it or why.</p><p>OWASP ranks prompt injection as the top risk for LLM applications and describes the indirect form as a model accepting input from external sources, like websites or files, that an attacker can influence. One detail from that guidance stuck with me: the injected text doesn’t have to be readable by a human, only parseable by the model (<a href="https://genai.owasp.org/LLM01/">OWASP LLM01</a>). So the page that looks perfectly normal to you can look very different to your agent.</p><p>My opinion is that this is the right mental model to hold: your agent is a reader who believes whatever it reads. That’s useful for getting work done and risky for everything else.</p><h3>Why do agents make this worse than chatbots?</h3><p>Because agents can do things. When a chatbot gets tricked, you get a weird answer. When an agent gets tricked, you can get an email sent, a record changed, a file deleted. The risk scales with permissions, not with how clever the model is.</p><p>I think this is where a lot of teams get caught out. It is easy to demo an agent with broad access because broad access makes the demo impressive. It is much harder to go back later and narrow it.</p><h3>Is there a real fix, or just mitigation?</h3><p>Mitigation, honestly. The UK’s National Cyber Security Centre published a blog in December 2025 arguing that prompt injection isn’t like SQL injection, because SQL injection has a clean fix (parameterized queries) while language models don’t have a firm boundary between data and instructions. Its view is that prompt injection may never be totally mitigated, and that the sensible goal is reducing likelihood and impact (<a href="https://www.ncsc.gov.uk/blog-post/prompt-injection-is-not-sql-injection">NCSC</a>).</p><p>I find that oddly freeing. Once you accept there’s no magic patch, you stop looking for one and start doing the unglamorous work:</p><p><strong>Give agents less power than feels necessary.</strong> Read-only by default. Write actions need sign-off. Separate dev and prod credentials. If I had to pick one thing out of the whole list, it would be this one, because it caps the damage no matter how the injection gets in.</p><p><strong>Keep data and instructions apart.</strong> Use structured roles and explicit data fields rather than gluing everything into a single prompt. It won’t make you immune, but it makes your system auditable.</p><p><strong>Check what comes back.</strong> Validate against the schema you expect, cap lengths, flag the weird stuff. Filtering phrases like “ignore previous instructions” helps a bit, but I wouldn’t lean on it, since attackers can reword endlessly.</p><p><strong>Put a person in front of the risky actions.</strong> Sending, spending, deleting, touching sensitive systems. A confirmation step feels like friction until the day it saves you.</p><p><strong>Test it like an attacker would.</strong> Feed your own workflow hostile documents and pages and see what it does.</p><h3>Why do I think teams are drifting toward structured agent platforms?</h3><p>This is the more speculative part, so take it as opinion.</p><p>I think people’s relationship with AI agents has changed from “look what it can do” to “what happens when it’s wrong?” That is a healthier question. And a natural consequence is that people get more comfortable with systems where responsibilities are divided into visible stages, like planning, building and testing, than with one all-purpose agent that does everything behind a single prompt.</p><p>That preference makes sense psychologically. We trust what we can inspect. Tools like <a href="https://8080.ai/?utm_source=medium&amp;utm_medium=content&amp;utm_campaign=manual&amp;utm_content=article">8080.ai</a>, which coordinate several specialized agents and plan architecture before execution, appeal partly for that reason, since each part has a narrower job. I’d add a caution, though: a structure like this doesn’t make prompt injection disappear. A poisoned message passed from one agent to another is still poisoned. What it can do is give you smaller scopes and more natural checkpoints to enforce, which is a better starting position than one agent with the keys to everything.</p><h3>What does this look like in a real workflow?</h3><p>Take a simple, very common setup: an agent that reads incoming customer emails, looks up the customer in a CRM, drafts a reply and logs the interaction.</p><p>Every step in that chain touches text someone else wrote. The email is written by a stranger. The CRM notes were typed by whoever last handled the account. The knowledge base article might have been pasted in from anywhere. If any one of those contains a line aimed at the agent, it’s sitting right beside the real task.</p><p>Now compare two versions of the same workflow. In the first, the agent can read everything, send replies on its own and edit CRM records. In the second, it can read the email and the CRM, draft a reply, and write the draft to a queue where a person approves it before it goes out. The model is identical. The prompt is identical. But the first version turns one hidden sentence into a possible data leak, and the second turns it into a draft a human looks at and rejects.</p><p>That’s really my whole argument in miniature. The difference between those two setups isn’t intelligence, it’s architecture. I’d much rather rely on a decision I made in the design than on the model noticing a trick in the moment.</p><h3>What would I check before trusting any agent setup?</h3><p>Three questions, whichever tool is involved:</p><ol><li>What is the worst thing this agent can do if it reads something hostile?</li><li>Which actions require a human to say yes?</li><li>Would I notice if it started behaving oddly?</li></ol><p>If the answers are “I’m not sure,” that’s the work to do first.</p><h3>Final thought</h3><p>Agents are going to read the open internet, inboxes and shared documents, and some of that content will be written to manipulate them. I don’t think the answer is to stop building agents. I think it’s to build them the way we build anything that has to live around untrusted input: with limits, with checks, and with a human holding the veto on the things that matter.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1efd1d0833a2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why Your Small SaaS Cloud Bill Keeps Growing (and the 6 Fixes I’d Make First)]]></title>
            <link>https://medium.com/@khushijigenshah/why-your-small-saas-cloud-bill-keeps-growing-and-the-6-fixes-id-make-first-62347ddfa836?source=rss-ec7f37f4433f------2</link>
            <guid isPermaLink="false">https://medium.com/p/62347ddfa836</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[no-code]]></category>
            <dc:creator><![CDATA[Khushi Shah]]></dc:creator>
            <pubDate>Thu, 05 Nov 2026 10:57:04 GMT</pubDate>
            <atom:updated>2026-11-05T10:57:04.479Z</atom:updated>
            <content:encoded><![CDATA[<p>A small SaaS cloud bill keeps growing because the decisions behind it are made fast, early, and almost never revisited. The fix is not a clever trick. It is a short loop: see the spend, remove what is idle, rightsize what is left, scale with demand, set alerts, and look again next month.</p><p>That is my short answer. Here is the longer version, including a few opinions you are free to disagree with.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4whLUNbAvuHnMeydbZxp9Q.png" /></figure><h3>My first opinion: cloud cost is a design problem, not a finance problem</h3><p>Most advice on this topic starts at the invoice. I think that is the wrong end. By the time a number shows up on a bill, the decisions that created it are weeks old, and the people who made them have moved on to the next feature.</p><p>The industry data points the same way. Flexera’s <a href="https://www.flexera.com/about-us/press-center/flexera-finds-cloud-value-is-rising-while-ai-waste-grows">2026 State of the Cloud report</a> estimates 29% of cloud spend is wasted, which the company describes as the first rise in five years. A <a href="https://virima.com/blog/flexera-2026-state-of-the-cloud-report">summary of the report</a> adds that 85% of organizations still call managing cloud spend a top challenge. That survey skews toward larger organizations, so I read it as a direction, not a forecast for any one startup. But the direction is clear: even teams with dedicated FinOps people are struggling, which suggests that more dashboards are not the whole answer.</p><h3>Why small teams overspend (it is not carelessness)</h3><p>Nobody plans to overspend. Early on, shipping is the only score that counts. So you pick the bigger instance because you will not have to revisit it. You keep staging up all weekend because shutting it down is one more thing to remember. You adopt a managed service to save a day.</p><p>I do not think any of that is irresponsible. I think it is rational in the moment and expensive in aggregate. The cost of a decision and the feedback on that decision are separated by a month, and humans are bad at learning from feedback that slow.</p><h3>The 6 fixes I’d make first</h3><p><strong>1. Audit by service, environment, and month.</strong> Use the provider’s native cost tool. Tag resources with an owner and an environment first, because untagged spend is where arguments start.</p><p><strong>2. Delete what is plainly idle.</strong> Unattached volumes, old snapshots, idle load balancers, abandoned databases, stale preview environments. This is the least risky saving available, so I would do it before anything else.</p><p><strong>3. Rightsize from usage, not instinct.</strong> Look at real CPU, memory, and connections over a representative period, then step down one size at a time while watching latency and errors. Be most careful with databases.</p><p><strong>4. Scale with demand, and match capacity to risk.</strong> Autoscaling suits stateless services. Spot or preemptible capacity suits work that can be interrupted, like batch jobs and build runners. I would keep it away from anything stateful.</p><p><strong>5. Set budgets and anomaly alerts.</strong> Send them where your team already looks. The goal is to shorten the time between a mistake and noticing it.</p><p><strong>6. Put a review on the calendar.</strong> Weekly for anomalies, monthly for trends, quarterly for commitments. One-time cleanups decay.</p><h3>My second opinion: AI-generated infrastructure raises the stakes</h3><p>Here is where I think the conversation is changing. When an AI tool generates a stack in minutes, its default choices, like instance sizes, always-on services, and managed add-ons, get accepted at the speed of generation. The work shifts from writing to reviewing. And you cannot review what you cannot see.</p><p>That is why I find architecture-first approaches interesting. <a href="https://www.producthunt.com/products/8080">8080.ai</a>, for instance, <a href="https://dev.to/8080_ai/how-agentic-workflows-replace-single-prompts-in-production-software-builds-1m1h">describes a flow</a> in which a project description is turned into architecture and tasks before agents write code, with infrastructure like containerization and CI/CD part of that plan. I am not claiming any tool lowers your bill on its own. My claim is narrower: a written architecture is something you can read with a cost lens before the first invoice, and I think that is a better moment to ask hard questions than month three.</p><h3>What a good first cost review actually looks like</h3><p>I think teams overcomplicate this. A useful first review fits in an hour and answers four questions. What are our three biggest line items? Which of them grew fastest? Which resources have no owner tag? And which environments are running when nobody is using them?</p><p>Those four questions usually produce a short list of changes that are safe to make. The part I would resist is jumping straight to long-term commitments or clever pricing models before that list is done. Committing to capacity you have not rightsized just locks in the waste for a year. That is my opinion, and plenty of FinOps practitioners would phrase it differently, but I would rather clean first and commit second.</p><h3>The psychology I keep noticing</h3><p>There is a quiet reason cost work gets postponed: it feels like the opposite of building. Features get applause. A deleted staging environment gets nothing. So the work waits until the bill hurts.</p><p>I think that is also why tools that surface decisions early are appealing. They turn cost from a month-end surprise into a design-time question, which is a much easier conversation to have. The appeal is not frugality. It is control over something that otherwise feels like it happens to you.</p><h3>Where I could be wrong</h3><p>Fair pushback: small teams do not have time to review architecture documents, and sometimes the right move is to ship, watch the bill, and fix it later. I partly agree. If you are pre-revenue and validating an idea, a slightly oversized setup is probably a fine trade. My view shifts once real customers depend on the system, because that is when rightsizing gets scarier and cleanup gets harder.</p><h3>If you only do one thing this week</h3><p>Pick one environment. Tag everything in it. Review a month of spend, remove what is clearly unused, and set one budget alert. That loop is small enough to finish and teaches you more about your bill than any report.</p><p>Cloud cost optimization is not about being frugal. It is about making sure the money you spend is buying something your customers can feel.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=62347ddfa836" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Can You Prevent AI Hallucinations in a Customer-Facing Product? My Take]]></title>
            <link>https://medium.com/@khushijigenshah/can-you-prevent-ai-hallucinations-in-a-customer-facing-product-my-take-a34ab18e58a8?source=rss-ec7f37f4433f------2</link>
            <guid isPermaLink="false">https://medium.com/p/a34ab18e58a8</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[no-code]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Khushi Shah]]></dc:creator>
            <pubDate>Wed, 04 Nov 2026 10:49:42 GMT</pubDate>
            <atom:updated>2026-11-04T10:49:42.613Z</atom:updated>
            <content:encoded><![CDATA[<p>Short answer: you can reduce AI hallucinations in a customer-facing product a lot, but you can’t promise to eliminate them, and I’d be wary of anyone who does. What works is a combination of grounding answers in sources you trust, limiting what the AI is allowed to say, showing where answers come from, and sending uncertain cases to a person.</p><p>That’s the practical answer. The part I find more interesting is why this has become such a pressing question, and what I think people are actually reacting to.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Pj_j5sPTWNzEnFeYX4rNCw.png" /></figure><h3>The moment the responsibility landed on the company</h3><p>I keep coming back to the Air Canada case. A customer asked the airline’s chatbot about bereavement fares after a family death, was told he could claim the discount retroactively, bought a full-price ticket, and then learned the real policy said the opposite. What stuck with me wasn’t the chatbot’s mistake. It was the airline’s defense, which amounted to arguing that it wasn’t responsible for what its chatbot said. The tribunal <a href="https://foxbusiness.com/lifestyle/air-canada-chatbot-gave-customer-wrong-info-airline-pay">rejected that and found the airline hadn’t taken reasonable care to make sure the chatbot was accurate</a>. The ruling is <em>Moffatt v. Air Canada</em>, 2024 BCCRT 149, and <a href="https://www.law360.ca/ca/articles/1804075">Law360 Canada has a fuller write-up</a>.</p><p>I think that case quietly changed how a lot of people think about this. Before it, a hallucination felt like a quirk of the technology. After it, a hallucination in a customer-facing product looks like a statement your company made. That’s a very different thing to be afraid of, and it explains why the conversation has moved from “how smart is the model?” to “how do we make sure we can stand behind what it says?”</p><h3>Where I think most teams go wrong</h3><p>My honest read is that most teams treat hallucination as a model-quality problem and look for a better model. In my experience of watching how these projects get discussed, the bigger issue is usually everything around the model: which sources it can read, who keeps them current, what happens when it doesn’t know, and whether anyone tests it against real questions before customers do.</p><p>Retrieval is the usual first fix, and it does help. But I’d push back on the idea that it settles things. Stanford researchers tested commercial legal research tools built on retrieval and found they <a href="https://hai.stanford.edu/news/ai-trial-legal-models-hallucinate-1-out-6-or-more-benchmarking-queries">made fewer errors than a general-purpose chatbot but still hallucinated in about one of every six queries or more</a>. That’s 2024 data from a legal setting, so I wouldn’t treat the number as universal. But the pattern, where retrieval improves things without finishing the job, matches what I’d expect elsewhere.</p><h3>The workflow I’d want before shipping</h3><p>If I were responsible for a customer-facing AI, this is the order I’d do things in.</p><p><strong>Ground it.</strong> Limit the AI to approved sources: help articles, docs, pricing pages, a verified knowledge base. Keep them current. Stale, contradictory pages are the quiet culprit, because the AI will confidently repeat whichever one it finds.</p><p><strong>Constrain it.</strong> Decide what it can discuss, what it can claim, and what it can do. “Only answer from the knowledge base, don’t invent policies, and if you’re unsure, say so and hand off” is a rule I’d rather enforce in several layers (prompts, allowlists, policy checks, output validation) than trust in one.</p><p><strong>Show your work.</strong> Link to sources inside answers. If an answer has no source, that should be visible. I’d be careful about displaying a “confidence score” taken from the model itself, since models aren’t reliable judges of their own accuracy. Signals like retrieval strength are more honest.</p><p><strong>Escalate on purpose.</strong> Low-confidence answers, legal or financial questions, upset or high-risk customers: those go to a person, with the conversation context attached. A handoff that makes the customer repeat everything feels like the AI quitting.</p><p><strong>Test with real questions.</strong> Not the tidy ones you’d write yourself. Ambiguous ones, edge cases, and a few deliberate attempts to get the AI to promise something it shouldn’t.</p><p><strong>Keep watching.</strong> Track grounding accuracy, escalation rate, and customer feedback, and treat every failed conversation as a bug report on your knowledge base.</p><h3>Why I think people are drifting toward platforms that plan first</h3><p>Here’s my opinion, and it’s an opinion rather than a finding. When you’re the one who’ll be held accountable for what a product says, you start to prefer tools that make their decisions reviewable. A reviewable plan feels safer than a large amount of generated code, because you can point to where a boundary or an escalation rule was decided.</p><p>That’s part of what I find interesting about platforms like <a href="https://dev.to/8080_ai/software-architecture-planning-why-design-comes-before-code-22c4">8080.ai</a>, which I work on the marketing side of. It uses a team of specialized agents (including Tech Lead, Backend, and QA roles), and the Tech Lead agent produces an architecture and a System Requirements Document before implementation agents write code. I’m not claiming that prevents hallucinations on its own. It doesn’t write your help center or decide your refund policy, and no build platform does. What it does is turn the places where those decisions plug in into something you can read and argue with, which is the kind of explicitness I’d want here.</p><h3>A scenario I keep imagining</h3><p>Picture a mid-sized software company that launches a support assistant on a Monday. It answers from the help center, it sounds friendly, and in the first week the numbers look great. Then a customer asks about a refund for an annual plan, and the assistant blends two versions of the refund policy, an old one and a new one, into an answer that matches neither. It sounds right, so the customer believes it.</p><p>Nothing about the model failed in a dramatic way. What failed was the surrounding system: two conflicting articles were both in the index, nobody owned freshness, no guardrail flagged a refund commitment for review, and no one had tested a question like that before launch. Every one of those is fixable, and none of them is a “better model” problem. That’s the main reason I’m skeptical of the idea that the next model release will make this go away. A smarter model reading contradictory sources still has to pick one.</p><p>The fix is also not glamorous. Merge or retire the conflicting articles. Assign an owner. Add a policy check on anything that promises money or dates. Send refund questions above a certain value to a person. Add that exact question to the test set so it never regresses. It’s a handful of small decisions, and the teams that make them early are the ones that don’t end up writing apology emails.</p><h3>What I’d say to a team about to launch</h3><p>Don’t promise zero hallucinations. Promise a system where they’re rare, where you can see them, and where a customer isn’t stranded when one happens. That’s a more honest claim, and it’s also a more defensible one, which matters more now than it did a couple of years ago.</p><p>I’d also assign a named human to the knowledge base before launch. In my view, an AI product’s accuracy ends up being a reflection of how well someone maintains the material it reads.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a34ab18e58a8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Can AI Route Support Tickets? My Honest Take on What Works]]></title>
            <link>https://medium.com/@khushijigenshah/can-ai-route-support-tickets-my-honest-take-on-what-works-4d5ad9f927bd?source=rss-ec7f37f4433f------2</link>
            <guid isPermaLink="false">https://medium.com/p/4d5ad9f927bd</guid>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[no-code]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Khushi Shah]]></dc:creator>
            <pubDate>Tue, 03 Nov 2026 10:58:27 GMT</pubDate>
            <atom:updated>2026-11-03T10:58:27.218Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>Short answer:</strong> Yes, AI can route support tickets, and for most teams it should handle the sorting. But I think the teams that get good results are the ones that treat routing as a system with an owner, not a switch they flip in their helpdesk settings.</p><p>I keep coming back to one observation about support work. The sorting part is the least interesting part of the job, and it is also the part where small mistakes get expensive. Someone reads a message, decides it is billing, and sends it to the billing queue. If it was really a login bug, the ticket now bounces, the customer waits, and everyone involved loses a little patience.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uGVKQDacbiflUj6p7yx3_w.png" /></figure><h3>Why I think routing is a bigger problem than it looks</h3><p>When people talk about support automation, they usually talk about chatbots and auto-replies. Routing gets less attention because it is invisible when it works. But it sits at the front of every interaction, so a bad call there affects everything after it.</p><p>One benchmark cited in <a href="https://devrev.ai/blog/ai-support-ticket-triaging">DevRev’s guide to AI triage</a> says 15 to 25 percent of manually triaged tickets get reassigned at least once, adding roughly 47 minutes each time. It is a vendor-published figure, so I would not quote it to your CFO. But it matches what most support leads will tell you from experience: the delay is usually the ticket sitting in the wrong place, not the difficulty of the problem.</p><h3>What I think AI handles well</h3><p>Classification is the obvious one. A model can read “I can’t get in” and tag it as an authentication bug, flag the customer tier, and suggest a priority faster than any person can. It is also consistent in a way people are not at 4 p.m. on a Friday.</p><p>Summarizing is the underrated one. A short note at the top of the ticket, covering what the customer wants and what the system classified, saves the next person from starting over.</p><h3>What I think it handles badly</h3><p>Judgment. A ticket from a long-standing customer who sounds quietly frustrated is not the same as a ticket with the same words from a new trial user. A message that hints at a legal problem or a security issue should not be routed by a model that is 70 percent sure. In my view, those cases go to a person, and the system should be built to say “I’m not confident” instead of guessing.</p><p>Maintenance is the other weak spot. A summary of Gartner’s 2025 findings from <a href="https://stealthagents.com/research/customer-support-ticket-triage-statistics-2026">Stealth Agents</a> reports that rule-based routing left unreviewed for more than 90 days dropped to roughly 52 to 57 percent classification accuracy. That is a secondary source, so I read it as a warning about drift rather than a hard number. Either way, routing logic that nobody revisits stops matching how the product and customers change.</p><h3>The trust problem nobody wants to talk about</h3><p>I think the real barrier to automating routing is not accuracy. It is trust. A support lead who has spent years learning which tickets are quietly urgent is being asked to hand that instinct to a system. Reasonable people hesitate.</p><p>What seems to work is making the system’s reasoning visible. If a ticket arrives with a note saying “classified as billing, confidence 62 percent, escalated because confidence is below threshold,” the lead can disagree, adjust the threshold, and see the effect. If the system just moves tickets around silently, nobody has any reason to believe it. I would rather have a slightly less accurate system I can inspect than a more accurate one I cannot.</p><h3>What I would measure in the first month</h3><p>Not response time, at least not first. Response time can improve because an auto-acknowledgment went out, while the ticket still sits in the wrong queue. I would watch reassignment rate (how often a ticket changes owner after first routing), time to reach the right team, and how many escalated tickets arrive with enough context to act on. Those three tell you whether routing is actually better or just faster-looking.</p><h3>The workflow I would follow</h3><p>If I were setting this up, I would keep it simple: connect the helpdesk and the customer data, classify intent and topic with a confidence score, score priority using rules the team writes, assign by skills and availability, escalate anything low-confidence or sensitive, and review misroutes every week. I would start with one high-volume ticket type and run the AI in suggestion mode first, so a human confirms each assignment until the numbers look trustworthy.</p><h3>What changes for the people on the team</h3><p>There is a human side to this that rarely makes it into the vendor pages. When sorting is manual, a few experienced people carry the routing logic in their heads, and the team depends on them. Automating it forces that knowledge onto paper: who handles what, which customers get which SLA, what counts as sensitive. That exercise is uncomfortable, and I think it is also the most valuable part. Even teams that never fully automate end up with clearer ownership.</p><p>It also changes what the job feels like. The person who used to sort tickets becomes the person who tunes the rules and reviews the exceptions. That is a more senior kind of work, and I suspect it is part of why teams adopt this. It feels like a promotion in responsibility rather than a replacement.</p><h3>Why I think teams are building this layer themselves</h3><p>Here is the part I find most interesting. Helpdesk defaults cover the basics, but real teams have specific needs: regional skills mapping, different SLAs by customer tier, a view of misroute rate by product area. Each is a small request. Together they become a software project nobody budgeted for.</p><p>I think the psychology matters here. People will hand off sorting if they can see the plan and keep control of the rules. That is why tools built around “plan first, then build” resonate with ops-minded teams. <a href="https://8080.ai/?utm_source=medium&amp;utm_medium=content&amp;utm_campaign=manual&amp;utm_content=article">8080.ai</a> is one example of a platform that works this way, describing itself as an <a href="https://dev.to/8080_ai">agentic coding platform</a> where coordinated agents produce architecture, code, tests, and deployment. Whether a team uses that, a framework, or a helpdesk’s built-in tools matters less to me than whether the routing logic stays visible and changeable.</p><h3>My bottom line</h3><p>AI can take over most of the sorting. It should not take over the judgment, the rules, or the review. If you keep those three with people, I think automated routing is one of the more sensible places to start with AI in support.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4d5ad9f927bd" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Can You Build a SaaS MVP Without Coding? My Honest Take for Non-Technical Founders]]></title>
            <link>https://medium.com/@khushijigenshah/can-you-build-a-saas-mvp-without-coding-my-honest-take-for-non-technical-founders-43d462058ccf?source=rss-ec7f37f4433f------2</link>
            <guid isPermaLink="false">https://medium.com/p/43d462058ccf</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[no-code]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[ai-agent]]></category>
            <dc:creator><![CDATA[Khushi Shah]]></dc:creator>
            <pubDate>Mon, 02 Nov 2026 10:38:28 GMT</pubDate>
            <atom:updated>2026-11-02T10:38:28.298Z</atom:updated>
            <content:encoded><![CDATA[<p>Yes, you can build a SaaS MVP without coding. A no-code or AI app builder, a tightly scoped idea, and a handful of real users are enough to get a working first version in front of people. That is the short answer, and it is true.</p><p>The longer answer is the one I find more interesting, because the real question is not whether it is possible. It is why so many founders have decided to do it this way, and what separates the ones who get somewhere from the ones who end up with a tidy demo nobody uses.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ku9V7fXG3KM0qwzYU_ku1w.png" /></figure><h3>Why are founders skipping the developer hunt?</h3><p>My honest read is that this is less about saving money and more about reducing regret.</p><p>If you are a non-technical founder, the traditional path asks you to do something uncomfortable. You have to explain a product that does not exist to someone who will build it literally, and then wait. By the time you see anything, you have invested months and a lot of emotional energy in a guess. Even if the developer is excellent, you are now committed to a version of the idea you have not tested.</p><p>An approach where you can see the product take shape in days changes how it feels to be wrong. You can be wrong early, in small ways, with real people watching. I think that is the real draw, and I think it explains why the shift is sticking rather than fading as a trend.</p><p>There is some data that supports the instinct, with a caveat about age. <a href="https://www.cbinsights.com/research/startup-failure-reasons-top/">CB Insights looked at 101 startup post-mortems</a>, and <a href="https://fortune.com/2014/09/25/why-startups-fail-according-to-their-founders/amp">as Fortune reported</a>, 42% of failed founders pointed to no market need and 29% to running out of cash. It is not new research, but it still points at something that shows up again and again in founder post-mortems: the expensive mistake is rarely a bug. It is building the wrong thing for too long.</p><h3>Does “no-code” mean “not serious”?</h3><p>I would push back on that framing. People sometimes treat no-code and AI builders as the toy version of software, and I think that misses what an MVP is for.</p><p>An MVP is a question you ask real users, not a finished answer. Whether the question is asked in hand-written code or in a visual builder matters much less than whether you asked it clearly and listened to the reply. I would rather see a founder run ten honest user conversations on a simple tool than spend a quarter polishing an app nobody has tried.</p><p>Where the “not serious” worry does have teeth is longevity. Some tools are brilliant for a first version and awkward after that. That is a legitimate concern, and it is the one I would weigh most when choosing a tool.</p><h3>What should the first version actually include?</h3><p>My rule of thumb is one core workflow, one primary user, one measurable outcome, basic accounts and data, and a feedback channel. If you cannot describe the workflow in about five steps, I would cut scope before touching a builder.</p><p>A concrete example: a client portal for small service teams. The user signs up, creates a project, invites a client, shares progress, and collects feedback. That is a real product in five steps. Everything else, such as billing, integrations, and fancy permissions, can wait until people actually ask for it.</p><h3>How do you choose between the different kinds of builders?</h3><p>This is where I think founders overthink. Roughly speaking, there are four families of tools.</p><p>Visual no-code platforms like Bubble, Glide, and Softr are strong for portals, directories, and workflow-heavy tools. Website builders like Webflow and Framer are the right pick when the main job is a polished public site. Automation tools like Zapier and Make connect other products together. And AI app builders such as Lovable, Bolt, and <a href="https://8080.ai/?utm_source=medium&amp;utm_medium=content&amp;utm_campaign=manual&amp;utm_content=article">8080.ai</a> generate a working application from a plain-language description.</p><p>If I had to give one piece of advice, it would be to ask a boring question before you pick: where do I expect this product to be in a year? If the answer is “still a simple portal,” a lighter tool is fine. If the answer is “a real product with paying customers and a team,” I would look harder at builders that care about structure under the hood, such as how the data model is organized and whether the architecture is planned before code gets generated. That planning step is the kind of thing that does not show up in a demo, and it is the kind of thing you will feel in month six.</p><h3>What do founders get wrong most often?</h3><p>In my view there are four recurring mistakes, and none of them are about the tools.</p><p>The first is building too much. Founders tend to underestimate how little is needed to learn something useful. The second is skipping validation, because building feels like progress and asking feels like exposure. The third is choosing a tool for this week’s needs instead of next year’s. The fourth is launching without any feedback loop, which means you have shipped a product and learned nothing from it.</p><p>If I could only fix one, I would fix the second. A landing page, ten conversations, and a waitlist cost almost nothing compared with a misdirected build.</p><h3>What does a sensible launch look like?</h3><p>Launch small and stay close. Give early access to your waitlist, onboard the first few users yourself, and watch where they hesitate. Track signups, whether people reach the core outcome, whether they return, the themes in their feedback, and whether anyone would pay.</p><p>Then iterate on the biggest friction first. It is tempting to respond to every request, but a feature list from five users is mostly noise until you can see a pattern.</p><h3>My bottom line</h3><p>You can build a SaaS MVP without coding, and for most non-technical founders I think it is the sensible default now. But the tool is not the strategy. The strategy is learning quickly whether people want what you are building, and a good builder is simply the thing that makes that learning faster and lighter on your time and attention.</p><p>The founders who do well, in my view, treat the first version as an honest question. The ones who struggle treat it as a verdict on themselves. If you can hold the first view, the rest of the process gets much easier.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=43d462058ccf" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to Build an AI Customer Support Agent That Knows When to Hand Off to a Human]]></title>
            <link>https://medium.com/@khushijigenshah/how-to-build-an-ai-customer-support-agent-that-knows-when-to-hand-off-to-a-human-2bdf0f73204a?source=rss-ec7f37f4433f------2</link>
            <guid isPermaLink="false">https://medium.com/p/2bdf0f73204a</guid>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[no-code]]></category>
            <category><![CDATA[ai-agent]]></category>
            <dc:creator><![CDATA[Khushi Shah]]></dc:creator>
            <pubDate>Fri, 30 Oct 2026 10:37:11 GMT</pubDate>
            <atom:updated>2026-10-30T10:37:11.926Z</atom:updated>
            <content:encoded><![CDATA[<p>Here’s my short answer. You build an AI customer support agent by deciding what it’s allowed to do, giving it a knowledge base you actually trust, designing the conversation on purpose, and making the path to a human so easy that customers never feel trapped. That last part is the one I’d bet most projects get wrong.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PXpuWwjEA5XD2PirS5iQtw.png" /></figure><h3>The Answer Usually Isn’t Where Support Agents Fail</h3><p>Most of the conversation about AI support focuses on answer quality, and I understand why. It’s the visible part. But with decent documentation behind it, a modern model handles routine questions well enough. What breaks the experience is everything around the answer: a stale help article, an agent with no defined limits, or a handoff that dumps the customer back at square one.</p><p>I think the numbers explain why. Gartner surveyed 321 service and support leaders in October 2025, and 91% reported executive pressure to implement AI in 2026, per <a href="https://stealthagents.com/research/ai-human-customer-support-workforce-statistics-2026">this summary of the findings</a>. When the pressure is that heavy, speed wins over design, and a chat widget gets wired to a model before anyone has decided what it should refuse to do.</p><p>Meanwhile, customers have been clear about what they want. In Gartner’s 2026 survey of 3,566 customers, 87% said companies using generative AI for customer service must provide access to a human agent (<a href="https://www.gartner.com/en/newsroom/press-releases/2026-08-04-gartner-survey-finds-87-percent-of-customers-say-companies-using-genai-for-customer-service-must-provide-access-to-a-human-agent0">Gartner</a>). My reading is simple: nobody is asking for a support agent that never involves people. They’re asking for one that doesn’t stand in the way.</p><h3>What I’d Decide Before Writing a Single Prompt</h3><p>Scope. I’d write down what the agent answers, what it never answers, what actions it can take, and when it escalates. Something like: answer questions about pricing, features, and setup; don’t touch refunds, account deletion, or legal questions; hand those to a person.</p><p>I’d start smaller than feels ambitious. In my opinion a narrow agent that’s right 95 times out of 100 does more for credibility than a broad one that’s right 80. Scope can grow when the data says it’s safe.</p><h3>The Knowledge Base Is the Real Product</h3><p>When a support agent gives a wrong answer, my first suspicion is the source material, not the model. Help center articles, FAQs, product docs, pricing pages, and cleaned-up past tickets are the raw material. Outdated pages, internal-only notes, and sensitive customer data should stay out.</p><p>I’d also assign a human owner and a quarterly review. A knowledge base nobody owns slowly turns into a liability, and the agent will repeat its mistakes with total confidence.</p><h3>Design the Conversation, Don’t Just Open a Chat Window</h3><p>The flow I’d aim for is simple: greet, capture intent, ask a clarifying question if the request is ambiguous, retrieve the answer, confirm it helped, and escalate if it didn’t. The clarifying question is the underrated step. “My payment failed” could be three different problems, and one short question is better than a confident guess.</p><h3>Trust Is the Metric I’d Put at the Top of the Dashboard</h3><p>Resolution rate and response time get most of the attention, and they matter. But in my opinion the number that decides whether support automation survives is trust, and it’s harder to measure. A customer who gets one confidently wrong answer from a bot may simply stop using that channel and email a person instead, which defeats the point of building it.</p><p>That’s why I’d be careful about celebrating “deflection” on its own. A conversation that ended without a human isn’t automatically a conversation that went well. I’d pair resolution rate with signals like how often customers ask for a person immediately, how often they come back with the same question, and what they say in follow-up surveys.</p><h3>Treat Escalation as the Main Feature</h3><p>If I could only get one thing right, it would be this. Billing issues, account deletion, legal questions, emotional or sensitive situations, and low-confidence answers should all go to a person. And the handoff should carry a summary and the full conversation, with a visible response-time expectation, so the customer never has to repeat themselves.</p><p>A handoff that forces someone to start over feels worse than no automation at all. I’d rather ship an agent that escalates a bit too often early on and tune it down with data.</p><h3>A Scenario I Keep Coming Back To</h3><p>Picture a customer who writes in because they think they were charged twice. This is a hypothetical, but it’s a common shape. A weak setup answers with a generic paragraph about billing cycles, the customer repeats the question, and eventually gets a canned “please contact support.” A well-designed one asks which invoice they mean, recognizes this as a billing dispute that belongs to a person, and hands it over with the invoice reference, a short summary, and a realistic response time.</p><p>The second experience isn’t more automated. It’s more honest about what the agent should and shouldn’t do, and that’s what customers remember.</p><h3>Test With Tickets You Already Have, Then Read the Failures</h3><p>Past tickets make an excellent test set. They contain the messy phrasing, the multi-issue messages, and the exceptions your docs forgot. After launch, I’d set a recurring weekly slot to read failed and escalated conversations. In my experience of how these projects are described, the fixes are mostly content updates, not model swaps.</p><h3>Where I Think Teams Go Wrong</h3><p>Three patterns stand out to me. The first is treating launch as the finish line, when it’s really the first day of tuning. The second is giving the agent too many abilities too early, so there’s no clear boundary to test against. The third is measuring only cost savings, which pushes everyone toward fewer handoffs instead of better ones. None of these are model problems. They’re planning problems.</p><h3>Why a Support Agent Starts to Look Like a Software Project</h3><p>A support agent feels like a prompt problem at first. Then the list grows: retrieval over your docs, helpdesk integration, escalation logic, logging, a review screen, a test harness. It’s an application.</p><p>That’s why I find the rise of platforms that build the whole system understandable. <a href="https://8080.ai/?utm_source=medium&amp;utm_medium=content&amp;utm_campaign=manual&amp;utm_content=article">8080.ai</a>, for example, is an agentic coding platform where coordinated AI agents handle architecture, code, tests, and deployment from one prompt (<a href="https://dev.to/8080_ai">8080 on DEV</a>), and it generates a system requirements document before coding begins (<a href="https://dev.to/8080_ai/top-5-ai-website-builders-in-2026-3p1p">DEV overview</a>). Whether you go that route or use a framework like LangGraph or CrewAI, I think the appeal is the same: people want to see and question the plan before something customer-facing gets built.</p><h3>What I’d Do First</h3><p>If I were starting tomorrow, I’d write the scope in two sentences, audit ten help articles for freshness, map the escalation path on a whiteboard, and run fifty old tickets through a prototype before showing it to anyone. Then I’d launch narrow and read every failure for the first month.</p><p>The agent doesn’t need to be impressive. It needs to be trustworthy, and trust in support mostly comes from knowing a human is one step away.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2bdf0f73204a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Can AI Write Technical Documentation From Code? My Take on What to Trust]]></title>
            <link>https://medium.com/@khushijigenshah/can-ai-write-technical-documentation-from-code-my-take-on-what-to-trust-9e6de4128b0c?source=rss-ec7f37f4433f------2</link>
            <guid isPermaLink="false">https://medium.com/p/9e6de4128b0c</guid>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[no-code]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Khushi Shah]]></dc:creator>
            <pubDate>Thu, 29 Oct 2026 11:22:23 GMT</pubDate>
            <atom:updated>2026-10-29T11:22:23.260Z</atom:updated>
            <content:encoded><![CDATA[<p>Yes, AI can write technical documentation from code. It can draft a README, describe an API, and sketch an architecture overview in the time it takes to make coffee. The better question, and the one I keep coming back to, is which parts of that draft deserve trust.</p><p>My short answer: trust it for structure, check it for meaning. Here is how I think about the difference, and why I believe more teams are changing how they approach docs altogether.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*erp-NP9107MO6vfjD8dGDg.png" /></figure><h3>Documentation does not fail because people are lazy</h3><p>Whenever documentation goes stale, the usual explanation is that nobody cared enough. I think that is wrong. Docs go stale because of timing. They are written when a feature ships, which is exactly when the team is tired and already thinking about the next thing. The code keeps changing and the document does not, so the gap widens quietly.</p><p>The numbers back up the feeling. In the State of Docs 2026 survey of 1,131 professionals, as <a href="https://docsio.co/blog/documentation-best-practices">summarized by Docsio</a>, keeping docs in sync with the product was the biggest challenge, nearly double the runner-up. That is not a motivation problem. That is a systems problem.</p><h3>What I would trust AI to do</h3><p>If I were handing AI a repo and a blank page, I would ask it to do the extraction work. List the endpoints. Describe the parameters. Pull out the environment variables. Organize it all into headings I can scan. This is tedious, mechanical, and easy to verify, which makes it close to a perfect job for a model.</p><p>I would also let it write the first plain-language explanation of a module. Most of us put that off for weeks. Having something on the page, even imperfect, changes the task from writing to editing, and editing is a far lighter lift. I suspect this single shift in effort explains a lot of why AI drafting caught on so fast.</p><h3>What I would not trust it to do</h3><p>I would not trust it to know why. A model can read what a function does, but it cannot know that the team chose this approach after an outage, or that a strange-looking branch exists for one legacy customer. Intent lives in people’s heads and in old conversations, not in the code.</p><p>I would also not trust it to say that something is still true. A confident paragraph about a config option reads the same whether the option exists or was removed last month.</p><p>Developers seem to feel this too. Stack Overflow’s 2026 Developer Survey, as <a href="https://itbrief.com.au/story/stack-overflow-survey-shows-developers-trust-ai-with-caveats">reported by IT Brief</a>, found that nearly half of respondents trust AI output when they can verify it easily, while only 6.6% would trust it for important decisions. My reading is that people are not rejecting AI. They are setting a condition: show me something I can check.</p><h3>The workflow I would follow</h3><p>I keep it simple, and I think simple is the point.</p><p><strong>Start with the reader.</strong> Before prompting, I would decide who the doc is for and what they need to do afterward. A new engineer setting up a local environment needs something very different from an on-call engineer at midnight.</p><p><strong>Feed it real context.</strong> Source files, config, tests, and the existing README. Tests matter more than people expect because they show intended behavior. I would keep secrets and generated code out.</p><p><strong>Ask for a structure.</strong> “Write documentation” produces fog. “Write a README with overview, setup, usage, API reference, and troubleshooting, using examples from the repo” produces something I can review section by section. I would also ask the model to flag anything it is unsure about.</p><p><strong>Review it like a pull request.</strong> Run the setup on a clean machine. Execute the examples. Check names and defaults against the code.</p><p><strong>Add the human layer.</strong> Edge cases, trade-offs, known limitations, and the reasons behind decisions. This is the part that turns a document into something that actually reduces questions.</p><p><strong>Give it an owner and a cadence.</strong> A doc without a maintenance habit is a future liability.</p><h3>Why I think teams are moving toward docs-as-a-byproduct</h3><p>Here is the part I find most interesting, because it is about psychology more than technology.</p><p>Documenting after the fact feels like homework. Reviewing something that already exists feels like progress. People will always choose the second experience if you let them, and I think that is the real force behind the shift.</p><p>The other force is trust. Teams want to see where a thing came from. That is why I think the most promising direction is not “AI writes your docs at the end” but “documentation gets created earlier and stays reviewable.” You can see versions of this in how people use repo-aware coding assistants and project instruction files, and you can see a more structural version in platforms like <a href="https://8080.ai/?utm_source=medium&amp;utm_medium=content&amp;utm_campaign=manual&amp;utm_content=article">8080.ai</a>, which writes a requirements document first and then sends later changes through as diffs the user accepts or rejects, per its own <a href="https://8080.ai/?utm_source=medium&amp;utm_medium=content&amp;utm_campaign=manual&amp;utm_content=article">site</a>. Whether a team uses that kind of platform or just a good habit, the principle is the same: put the written record near the start of the work, not the end.</p><h3>The mistake I would watch for</h3><p>The biggest risk is not bad AI. It is good-looking AI. A polished, well-structured draft creates a feeling of completeness that discourages checking. The cleaner the document looks, the more deliberately I would review it.</p><p>If I had to put the whole opinion into one line, it would be this: let AI do the drafting, and keep the truth in human hands.</p><h3>Where I would start</h3><p>Pick one doc type, probably the README or an onboarding guide. Write down the reader and the goal. Run one draft through the workflow above and see how much of it survives review. That quick experiment will tell you more about where AI helps your team than any benchmark will.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9e6de4128b0c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AI-Generated Wireframes: Are They Usable? My Take on What Makes Them Work]]></title>
            <link>https://medium.com/@khushijigenshah/ai-generated-wireframes-are-they-usable-my-take-on-what-makes-them-work-163e00242ab8?source=rss-ec7f37f4433f------2</link>
            <guid isPermaLink="false">https://medium.com/p/163e00242ab8</guid>
            <category><![CDATA[no-code]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[technology]]></category>
            <dc:creator><![CDATA[Khushi Shah]]></dc:creator>
            <pubDate>Wed, 28 Oct 2026 10:40:05 GMT</pubDate>
            <atom:updated>2026-10-28T10:40:05.873Z</atom:updated>
            <content:encoded><![CDATA[<p>Short answer: yes, an AI-generated wireframe can be usable. But “usable” is doing a lot of work in that sentence, and I think most of the disappointment people feel with these tools comes from skipping over what it actually means.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Guu9ZtgcsVeWQkYYpIkMOQ.png" /></figure><h3>Usable doesn’t mean good-looking</h3><p>Here’s my definition. A usable wireframe is one a team can look at and make a decision with. It shows structure, flow, and hierarchy clearly enough that people can say “yes, build this” or “no, move that.” It leaves room for real content. It tells you what the main action is on every screen, and it carries a few notes about behavior so nobody has to guess.</p><p>A wireframe that looks polished but can’t support a decision isn’t a good wireframe. It’s an illustration. And AI tools are very, very good at illustrations.</p><h3>Why I think adoption has moved so fast</h3><p>The number I keep coming back to is from the <a href="https://pub.towardsai.net/ai-in-design-report-2026-6-key-findings-from-906-designers-b94a10774db5">AI in Design 2026 report</a> by Designer Fund and Foundation Capital. In a survey of 906 designers, 91% said they use AI at least weekly, up from roughly 54% the year before. That’s a big jump for one year.</p><p>Speed is the obvious explanation, and it’s part of it. But my read is that the bigger pull is psychological. Anyone who has done early design work knows the blank-canvas feeling: the first twenty minutes where nothing is on the page and every choice feels loaded. AI removes that. You get something to react to, and reacting is easier than inventing.</p><p>The side effect, in my opinion, is that the job quietly shifts. When drafting is fast, the valuable skill is no longer drawing the boxes. It’s deciding which draft is right and why. People who adapt to that shift tend to get a lot out of these tools. People who treat the first output as the answer tend to get frustrated.</p><h3>Where I think AI wireframes go wrong</h3><p>My biggest worry is false confidence. A tidy, well-labeled layout feels finished, and a feeling of “finished” shuts down the questions that matter. Does a new user know what to do first? What happens when the list is empty? What does this screen look like with a name that’s forty characters long?</p><p>The second problem is that the tool doesn’t know your product. It doesn’t know your users’ habits, your compliance limits, or the legacy system your new screen has to sit next to. It will happily propose a flow that looks sensible and quietly breaks a rule that only your team knows.</p><p>Neither of these is a reason to avoid the tools. They’re reasons to be deliberate about how you use them.</p><h3>What I’d want before trusting one</h3><p>If I were reviewing an AI-generated wireframe, this is the short list I’d want satisfied:</p><ul><li><strong>A real brief behind it.</strong> Who it’s for, the job they’re trying to do, the key screens, the primary action, and the constraints. A vague prompt gets a vague wireframe, and no amount of review fixes a vague starting point.</li><li><strong>More than one option.</strong> I’d want to see at least three directions side by side. A single draft invites polishing. A set of drafts invites choosing.</li><li><strong>A structure-first review.</strong> Check the flow, hierarchy, and next steps before anyone comments on color or style.</li><li><strong>A human pass on hierarchy and spacing.</strong> This is where taste and judgment still matter most.</li><li><strong>Notes on behavior.</strong> A wireframe without intent attached is just boxes.</li></ul><h3>Why the brief matters more than the tool</h3><p>If I could change one habit, it would be how people write the first prompt. “Make a wireframe for an onboarding flow” gets you a generic onboarding flow. Compare that with something like: a mobile onboarding flow for a fitness coaching app, aimed at busy professionals, three steps to finish a profile, screens for welcome, goal selection, and schedule, one primary action per screen, no more than three taps overall. The second version isn’t longer for the sake of it. Every added detail removes a guess the tool would otherwise make on your behalf.</p><p>I’d also add one sentence that people leave out: ask for low fidelity and say you want structure and flow, not visual style. In my opinion that single line saves a surprising amount of wasted attention, because it keeps everyone reviewing the thing that’s actually up for decision.</p><p>Then ask for several versions. A card layout next to a list layout. A dense screen next to a sparse one. The differences between them usually teach you more about the problem than any single draft would.</p><h3>Testing is the part people skip</h3><p>If there’s one habit I’d push on every team, it’s putting the wireframe in front of a few people who didn’t make it. The classic guidance from Nielsen Norman Group is that <a href="https://nngroup.com/articles/why-you-only-need-to-test-with-5-users/">five participants will surface about 85% of the usability problems</a> in a first round, after which you fix what you found and test again. They’re also clear that you need more people if your product serves several distinct groups.</p><p>That’s a small investment for what it buys. AI made the first draft almost effortless, which makes it even more tempting to skip the part where a real person tries to use it.</p><h3>The part I’d watch next: what happens after approval</h3><p>The place I think this gets interesting is the handoff. A wireframe gets approved, and then someone has to turn it into a real product without losing the decisions that were made. That gap between “agreed” and “built” is where intent tends to leak out.</p><p>It’s one reason I think structure-first tools are getting attention on the build side too. <a href="https://8080.ai/?utm_source=medium&amp;utm_medium=content&amp;utm_campaign=manual&amp;utm_content=article">8080.ai</a>, for instance, generates a system requirements document and architecture diagrams before it writes any code, which is the same instinct as a wireframe: agree on the structure, then build on top of it. Whether a team uses that approach or another, the principle holds. The more clearly the plan is written down before the build starts, the less gets lost on the way.</p><h3>Where I land</h3><p>AI-generated wireframes are usable when a person has put their judgment into them. The tool is excellent at exploration: variations, structures, first drafts. The team is still the one that has to decide, test, and own the intent. If you keep that split in mind, I think the tools are a genuine upgrade to how early design gets done. If you don’t, you get beautiful drafts that nobody can build from.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=163e00242ab8" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>