<?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 Ian Grant on Medium]]></title>
        <description><![CDATA[Stories by Ian Grant on Medium]]></description>
        <link>https://medium.com/@ianjamesgrant?source=rss-c72a99678589------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*w-YsW3xAXs7oNG0t.</url>
            <title>Stories by Ian Grant on Medium</title>
            <link>https://medium.com/@ianjamesgrant?source=rss-c72a99678589------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 21:14:44 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@ianjamesgrant/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[How AI Can Help Solve the “Post-Workshop Drift” Problem]]></title>
            <link>https://medium.com/@ianjamesgrant/how-ai-can-help-solve-the-post-workshop-drift-problem-e9966d70107c?source=rss-c72a99678589------2</link>
            <guid isPermaLink="false">https://medium.com/p/e9966d70107c</guid>
            <category><![CDATA[mcp-server]]></category>
            <category><![CDATA[product-management]]></category>
            <category><![CDATA[agentic-workflow]]></category>
            <category><![CDATA[facilitation]]></category>
            <category><![CDATA[ai-product-engineering]]></category>
            <dc:creator><![CDATA[Ian Grant]]></dc:creator>
            <pubDate>Sat, 08 Aug 2026 07:01:03 GMT</pubDate>
            <atom:updated>2026-08-08T07:01:03.218Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*r2XpluGePZWOxU0P" /><figcaption>Photo by <a href="https://unsplash.com/@simisola?utm_source=medium&amp;utm_medium=referral">Simi Iluyomade</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Why visual collaboration tools become digital graveyards and how MCP can help turn them into durable context for AI.</h3><p><em>Written for the product and engineering teams that run the workshops, then wonder why nothing survives them.</em></p><p>I can tell you exactly what came out of the best discovery workshop I ran last year however, I couldn’t tell you the last time anyone opened the board.</p><p>I don’t believe that’s a discipline problem, everyone in the room did the work. We diverged properly, argued well, and someone said the thing at 2pm that reframed the entire opportunity. We captured it.</p><p>The board is still sitting there and it’s genuinely good. It’s also, functionally, write-only storage, essentially a medium the whole team writes to enthusiastically and nobody ever reads back.</p><p>For years the only available fixes were human: better summaries, a Confluence page someone volunteers to write, or a ritual of revisiting the board at the start of the next quarter that survives exactly two quarters. They all ask a person to do boring work, later, for someone else’s benefit.</p><p>That constraint has changed, the pattern that works is just isn’t sexy:</p><blockquote><strong>Extract once. Commit. Work from the files.</strong></blockquote><h3>Everyone remembers the room. Nobody reopens the board.</h3><p>Miro, Lucid, FigJam and Confluence whiteboards are extraordinarily good at the thing they were built for.</p><p>They make design thinking legible to people who don’t practise it. They let a sceptical commercial stakeholder push a sticky note across a wall and, in doing so, commit to a position in front of their peers. They’re inclusive in a way a Word document has never been.</p><p>And then the workshop ends.</p><p>What remains is a spatial artefact that made complete sense to twelve people for ninety minutes. Six weeks later, a new team member opens it and sees a wall. Not a document, a wall, or worse, a corporate Jackson Pollock.</p><p>There’s no obvious reading order. Half the meaning is carried in colour, position, proximity and dot-votes. The alignment everyone felt walking out of the room was real, but it lived in the conversation. The board didn’t capture it all, only its residue.</p><p>I’ve watched this produce something worse than forgetting. A board gets referenced months later, and two people who were genuinely aligned in the room now confidently hold different readings of the same cluster of stickies.</p><p>Nobody is being difficult. They’re both reading a Rorschach test and reporting what they see.</p><h3>MCP is the pipe, not the memory.</h3><p>The Model Context Protocol is an <a href="https://modelcontextprotocol.io/docs/getting-started/intro">open standard for connecting AI applications to external tools and data</a>.</p><p>An MCP server acts as an adapter in front of another system. For product and engineering teams, that lets an agent working close to the code inspect a <a href="https://developers.miro.com/docs/miro-mcp">Miro board</a> or a <a href="https://help.lucid.co/hc/en-us/articles/42578801807508-Integrate-Lucid-with-AI-tools-using-the-Lucid-MCP-server">Lucid document</a> without somebody manually copying every sticky into a prompt.</p><p>But MCP isn’t a memory system. It’s the pipe through which the agent reaches the board.</p><p>There’s also a cost. Tool definitions and intermediate results consume context. Anthropic’s engineering team <a href="https://www.anthropic.com/engineering/code-execution-with-mcp">demonstrated a workflow</a> (retrieve a meeting transcript from Google Drive, attach it to a Salesforce lead) that consumed 150,000 tokens through direct tool calls, and 2,000 when the agent instead wrote code against the same tools as an API. A 98.7% difference. That’s a striking example rather than a universal benchmark, but the underlying constraint is real.</p><p>If a script or CLI is cheaper for a repeatable job, it probably is. The interesting question isn’t whether every integration should use MCP. It’s what becomes possible once an agent can reach a board that was previously trapped inside its own interface.</p><h3>The first time you ask a board a question.</h3><p>Point an agent at a board and ask something that would usually take a person twenty minutes of zooming and scrolling to answer.</p><ul><li><em>“What did we decide about pricing, and which options did we reject?”</em></li><li><em>“Which problems are supported by research, and which are still assumptions?”</em></li><li><em>“Pull out everything on this board that touches identity or authentication.”</em></li></ul><p>When it comes back with a coherent answer, the first reaction is usually: “Excellent, a search engine for my boards!”</p><p>That undersells it.</p><p>The useful move isn’t the question your ask, it’s what you do with the answer.</p><p>Write the result to Markdown, structure it, and commit it to the repository where the product is being built. Don’t leave it sitting in a chat window.</p><p>The moment it becomes a file, it stops being a temporary search result and becomes a durable input: versioned, diffable, portable, cheap to read, and accessible to every agent and human working in the repository. The documentation that lives in the product, moves and evolves with it over time.</p><p>The MCP server was the extraction tool. It doesn’t need to become a permanent runtime dependency for every question the team asks afterwards.</p><h3>A Monet up close.</h3><p>The value of this pattern scales directly with how disciplined the original board was, and that’s the boring part nobody wants to hear (or do).</p><p>I’ve seen boards that present like a Monet: noise at close range, coherent only when you zoom out far enough that the individual marks disappear.</p><p>An MCP server can hand an agent the frames, the positions, the parent-child relationships. What it can’t hand over is the meaning of a convention nobody recorded. An agent doesn’t have a zoom.</p><p>A board with 340 stickies in loose spatial clusters and no frame labels will get you a confident, fluent, useless summary of 340 stickies. If pink means “customer evidence” and blue means “team hypothesis”, the agent can’t apply that distinction unless the board says so.</p><p>The fix is unglamorous: pick a standard template that fits your workshop objective and how your organisation actually works, and then use it unmodified.</p><p>I understand the urge to improve the canvas. Every facilitator has it, and every improved canvas differs from the last one which is fine when the only readers are the twelve people who were in the room, and fatal the moment a machine is reading. Bespoke means differently-shaped every time, and differently-shaped inputs produce inconsistent outputs. The benefit doesn’t scale across teams, then the teams concludes the integration doesn’t work.</p><blockquote>Boring and repeatable beats clever and bespoke, because repeatable structure is something both humans and machines can learn to read.</blockquote><h3>Your board needs a README.</h3><p><em>Structure gets you most of the way, but context gets you the rest.</em></p><p>A template tells an agent what the boxes are. It doesn’t explain what the marks inside those boxes mean.</p><p>A README also tests the facilitator’s command of the method. If you can’t explain the reading order, the conventions and the status of a board, you probably don’t understand the template as well as you need to. Spend the time upfront to understand what the template does and how it does it.</p><p>Here’s a composite README, assembled from a few boards I’ve seen. The details are intentionally vague but the point of the exercise remains.</p><p>A platform team runs an opportunity workshop for a risk-scoring feature inside a lending product. They use a standard opportunity canvas. The frames are labelled, nothing is freehand, and the board looks excellent. They also use colour (because everyone does):</p><ul><li>Yellow for observed behaviour from research.</li><li>Pink for direct customer quotations.</li><li>Blue for team hypotheses.</li><li>Dot-votes for relative priority.</li><li>A greyed-out area for parked ideas.</li></ul><p>None of that is written on the board. It didn’t need to be because everyone in the room knew.</p><p>Now ask an agent: <em>what are the top three validated user problems here?</em></p><p>The answer comes back fluent and wrong in three specific ways.</p><ol><li>It treats the parked cluster as active scope, because the grey area was never defined.</li><li>It merges <em>Solutions Today, </em>existing workarounds, with <em>Solution Ideas</em>, because both frames contain product-shaped nouns.</li><li>Worse, it reports a blue sticky as a user finding: “Users report that…”, a team hypothesis, written by the team on a Tuesday, comes back out as customer evidence.</li></ol><p>That’s the real damage. The output isn’t gibberish you can immediately reject. It’s competent, confident work that has quietly laundered an assumption into evidence.</p><p>Nobody lied, the board simply never said which was which.</p><p>The solve; Add one frame in the top-left corner, before the workshop begins. Call it <em>How to read this board</em>. It records:</p><ul><li>The decision the board exists to inform.</li><li>What’s explicitly out of scope.</li><li>The template and its source.</li><li>The reading order of the frames.</li><li>What each colour means.</li><li>What a dot-vote does and doesn’t signify.</li><li>How parked material is identified.</li><li>Any team-specific terminology.</li><li>The owner, date and status: <em>draft</em>, <em>unvalidated</em>, <em>reviewed</em> or <em>superseded</em>.</li></ul><p>Six minutes. Most of it is known before the workshop starts.</p><p>Ask the same questions again and the answer changes. Hypotheses stay labelled as hypotheses. The parked cluster is excluded, and the agent says why. Existing workarounds stay separate from proposed solutions.</p><p>That frame is how you write down what the room knew. And it isn’t really for the machine, the machine finally made everyone write it, it’s for the person who joins in March and opens a board from November.</p><h3>Get it to where the work is.</h3><p><em>Extraction is only half the value. The other half is where the output goes.</em></p><p>For product and engineering teams, that place is the product repository, next to the code.</p><p>Not because every piece of organisational knowledge belongs in Git, but because the repository is where the downstream work happens. It’s where developers already operate, where agents already look for context, and where changes can be versioned and reviewed.</p><p>A practical shape is a docs/ directory containing the extracted artefacts. Each file carries a short metadata block recording its source board, extraction date, participants, owner, status and a link back to the original.</p><p>The Vision document. Opportunity canvases. Journey maps. Architecture decisions. C4 views. Committed and reviewed through pull requests like anything else, and explicitly superseded rather than silently forgotten.</p><p>What you’ve built is a local retrieval layer with almost no additional infrastructure. No vector database. No ingestion pipeline. No new knowledge platform to maintain. Just files, in the place the agent is already working.</p><p>This is also why BMAD remains central to how I work. In a BMAD-shaped repository, planning artefacts aren’t documents someone reads once. They become durable context for downstream agents, and implementation inherits explicit, versioned decisions instead of re-deriving them from a chat log.</p><p>You don’t need to adopt BMAD to get the benefit. You just need the files to exist in the right place, in a form the next person or agent can use.</p><p>There’s a second-order effect worth calling out too, once the extracted context lives beside the code, the drift between what the team decided and what the product does becomes visible. You can ask: “<em>Which decisions from our opportunity workshop are no longer reflected in the product?”</em></p><p>Right now that drift is invisible, because the board and the code live in different universes and nobody is comparing them.</p><h3>The onboarding test.</h3><p>If you want a single measure of whether this is working, try this one.</p><p>A new engineer joins on Monday. They clone the repository, launch whatever agent the team uses, and ask four questions. <em>What is this product? Why does it exist? What problem does it solve, and for whom? How does it actually work?</em></p><p>If they get four good answers, with links to the decisions and original boards behind them, the system is working.</p><p>If they need a document safari through Confluence, Drive, Slack and a Miro board somebody has to go and find, followed by a forty-minute call with a senior engineer who explains it from memory, then every answer they end up with is a reconstruction.</p><p>Reconstructions routinely cause drift.</p><p>That safari isn’t a small tax by the way. Atlassian’s <a href="https://www.atlassian.com/blog/state-of-teams-2025">State of Teams 2025</a>, which surveyed 12,000 knowledge workers and 200 executives, found that executives and teams alike spend a quarter of the working week searching for information. Stack Overflow’s <a href="https://survey.stackoverflow.co/2022/#section-productivity-impacts-daily-time-spent-searching-for-answers-solutions">2022 developer survey</a> put 62% of respondents at more than thirty minutes a day searching for answers or solutions to problems, with one in four spending more than an hour. That stacks up.</p><p>We consider it the nature of things, the weather so to speak, we accept it because we don’t control it. It isn’t weather. It’s a consequence of storing knowledge where it was created rather than where it’s needed.</p><h3>The excuse is gone. The work isn’t.</h3><p>None of this is really about MCP. The protocol is merely a pipe.</p><p>The hard part remains upstream: choosing consistent effective templates, recording what the conventions mean, and making extraction a deliberate step in the delivery process rather than something somebody might do if there’s time.</p><p>What the technology has removed is the requirement for a person to perform the boring transcription, the step that was always going to happen later and almost never did.</p><p>The best thinking your team does will still happen in a room, on a wall, with people arguing. That hasn’t changed, and I genuinely hope it doesn’t.</p><p>What’s changed is that the wall no longer has to be the last place that thinking lives.</p><p><em>If you’ve wired a facilitation tool into your product delivery workflow, I want to hear how it actually went, particularly what broke.</em></p><p>— IG</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e9966d70107c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Your engineers aren’t losing their craft. They’re being asked to lead.]]></title>
            <link>https://medium.com/@ianjamesgrant/your-engineers-arent-losing-their-craft-they-re-being-asked-to-lead-ed577d8fc31c?source=rss-c72a99678589------2</link>
            <guid isPermaLink="false">https://medium.com/p/ed577d8fc31c</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[ai-software-engineering]]></category>
            <category><![CDATA[change-management]]></category>
            <category><![CDATA[leadership-skills]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <dc:creator><![CDATA[Ian Grant]]></dc:creator>
            <pubDate>Fri, 24 Jul 2026 13:25:48 GMT</pubDate>
            <atom:updated>2026-07-24T13:25:48.025Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="A potter in the process of forming a clay bowl on a potter’s wheel. Signifies the patient mastery and joy built over years of practice and delivery. The very thing that modern software engineerins stands to lose in the face of AI… joy." src="https://cdn-images-1.medium.com/max/1024/0*CaNnUiTAi9cxCsYM" /><figcaption>Photo by <a href="https://unsplash.com/@roberto_sorin?utm_source=medium&amp;utm_medium=referral">Roberto Sorin</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>I’m frequently having the same conversation with engineering leaders.</p><p>It starts as a tooling question. Which agent? Which harness? Which CLI? How much autonomy should we allow? Should we standardise now or let teams keep experimenting?</p><p>Then, a few minutes in, the real question arrives:</p><p><em>How do I help my best people through this without making them feel like the work they spent years mastering has been devalued?</em></p><p>Most coverage of agentic engineering still treats it as a productivity story measured in velocity metrics and line counts. But underneath the efficiency narrative lies a fundamental shift in leadership and identity. We aren’t just changing engineering tools; we are altering the core unit of human leverage in software delivery.</p><h3>Agentic AI is not a plugin, it changes the unit of work.</h3><p>The instinct is to file agentic engineering under “better tools”, the next autocomplete or the smarter IDE sidebar that writes the boilerplate so humans can get on with the interesting work.</p><p>That framing is too small.</p><p>Autocomplete left the engineer working at the same operational level: the line, the function, the file, the pull request. Agents shift the unit upward. The work is no longer just “write this code.” It becomes: define the job, supply the context, set the constraints, decide what can be delegated, verify the result, and own the consequences.</p><p>That is a different job shape entirely.</p><p>A Cisco-authored piece on LangChain describes agentic engineering as a multi-agent coordination model: agents with roles, shared memory, observability, and responsibility across the delivery pipeline. Anthropic’s 2026 Agentic Coding Trends Report echoes this shift, noting that software development is moving from writing code to orchestrating agents, concentrating human judgement around direction, review, validation, and strategy. CIO puts it even more bluntly, describing engineers moving from creators toward curators.</p><p>You can see it in the early benchmarks. Anthropic reports TELUS shipping engineering code 30 percent faster. Rakuten gave Claude Code a task inside a 12.5-million-line vLLM codebase that ran autonomously for seven hours and hit 99.9 percent numerical accuracy against the reference method.</p><p>Those examples aren’t the whole story — quality, security, maintainability, and accountability deserve their own discussion — but they explain why engineers feel that this shift is fundamentally different, not just faster.</p><p>Treating this as an incremental tooling rollout is the first major mistake leaders make.</p><h3>The loss is real.</h3><p>Here is what leaders need to say out loud: Something real is being disrupted and lost.</p><p>Not the whole craft, and not the value of deep technical understanding. But a very specific, deeply ingrained feedback loop is changing.</p><p>Many engineers built their professional identity around the act of making ( I was one of them). Writing the function. Finding the subtle bug. Untangling ugly architecture. Watching a test suite turn green because they understood the system better than they did an hour ago.</p><p>That feeling matters. It is one of the primary reasons people stay in the discipline long enough to become great.</p><p>Annie Vella captured this honest reality: for many engineers, the identity was never “coder” — it was <em>builder</em>. Not overseer. Not manager. Now, the industry is asking them to step into a role that looks suspiciously like management, on a timeline they did not choose.</p><p>Addy Osmani describes this trajectory as <em>coder to conductor to orchestrator</em>. Mechanically, that is accurate. Emotionally, it requires care. Telling an engineer, “Congratulations, you are a manager of agents now,” often triggers a sense of loss rather than leverage.</p><p>A better frame is this:</p><p><strong>Your engineers are not being asked to become people managers. They are being asked to lead work.</strong></p><p>Leading work means deciding what to delegate. Breaking ambiguous problems into agent-sized pieces. Supplying sufficient context. Defining “good”. Knowing when to intervene. Reviewing output with healthy skepticism. Capturing lessons so subsequent runs start smarter.</p><p>That is work leadership, and it is a craft in its own right.</p><p>However, it won’t feel like a craft if leaders focus solely on licence counts, adoption curves, and hours saved. Productivity is what the organisation receives; identity is what the engineer must rebuild.</p><p>Your role as a leader isn’t to argue the feeling away. It is to help build the next source of pride: the clean decomposition, the well-scoped prompt context, the review that catches a subtle edge case, and the system that holds firm because a human understood where judgement belonged.</p><h3>The three skills to teach deliberately.</h3><p>Skipping straight to tools while ignoring the capability gap is where most transitions fail.</p><p>To turn agentic engineering into a durable organizational capability rather than a short-lived burst of experimentation, teach these three skills explicitly:</p><h3>1. Delegation: Matching tasks to actual skill, not confidence</h3><p>Most engineers have been rewarded for solving complex problems themselves. Delegation is not naturally attractive to someone whose identity rests on direct technical execution.</p><p>In traditional management, “it’s faster if I do it myself” points to a failure to delegate. In agentic engineering, it points to a missing system boundary. It signals that the task was poorly scoped, the context was incomplete, or the cost of verification exceeded the cost of execution.</p><p>The classic skill-will matrix is only useful here after removing half of it. Agents do not lack “will” — they are willing to a fault, often eager and sycophantic by design. Their confidence rarely matches their competence.</p><p>The operational question is: <em>Can this agent execute this task, right now, in this codebase, with this context, under this level of risk?</em></p><p>A strong delegation candidate is bounded, reversible, easy to test, low on hidden context, and clear on completion criteria. A poor candidate is ambiguous, politically loaded, architecturally cross-cutting, or dependent on unwritten taste.</p><p>Before assigning a task, run this quick task-fit check:</p><ul><li>Is the task small enough to inspect easily?</li><li>Does the agent have all required context?</li><li>Can failure be cheaply reversed?</li><li>Can output be verified quickly?</li><li>Are hidden constraints explicitly written down?</li><li>Is a human explicitly holding the final judgement?</li></ul><p>If the answer to any of these is no, don’t ban the tool instead, improve the delegation boundary.</p><h3>2. Feedback: Correcting vs. Coaching</h3><p>Engineers are fluent in code review: precise, direct, and aimed at peers who can argue back. That style does not build agentic capability.</p><p>Saying “this is wrong” might fix the immediate output, but the agent won’t extract the underlying principle: why it was wrong, when the rule applies, and where that constraint should live so the team doesn’t have to re-teach it tomorrow.</p><p>Simon Willison likens LLMs in production to “digital interns” working from detailed instructions. Interns don’t improve from generic corrections; they improve when given clear feedback on what was wrong, why it matters, and what good looks like.</p><p>Agents require that same feedback structure, plus one critical addition: <strong>persistence</strong>.</p><ol><li><strong>Correction:</strong> What needs to change.</li><li><strong>Reason:</strong> Why it matters.</li><li><strong>Principle:</strong> How to apply the lesson going forward.</li><li><strong>Home:</strong> Where the lesson lives.</li></ol><p><em>Correcting an agent fixes a single file; coaching an agent upgrades the entire system.</em> High-leverage feedback never stays trapped in an ephemeral chat window. It gets codified into repository conventions, architecture records, test harnesses, or review checklists.</p><p>Treat those instruction files as production assets: version them, review them, and prune them.</p><h3>3. Provenance: Preserving decision logic</h3><p>This is the capability leaders skip most frequently, yet it dictates whether learning compounds across the team.</p><p>Memory without provenance is just a rumour with a longer shelf life. A note stating “this approach failed” is useless weeks later if it omits <em>why</em>. Was it rejected because it was insecure, architecturally inconsistent, too expensive, or simply because the underlying model wasn’t capable enough at the time?</p><p>Without context, future engineers (and future agents) end up re-litigating decisions that were already made. The inverse risk is equally real: as Salesforce and Augment point out in their research on agentic memory, sharing context too loosely without lifecycle controls and source tracking doesn’t just preserve knowledge — it preserves contamination.</p><p>At the end of meaningful agent sessions, capture the minimum useful provenance:</p><ul><li>What outcome was achieved?</li><li>What approaches were attempted and rejected, and why?</li><li>What evidence supported the final choice?</li><li>What instruction, test, or convention needs updating?</li><li>When should this decision be revisited?</li></ul><h3>The leadership job underneath</h3><p>This isn’t an engineering-tools problem; it is a change-management problem in technical clothing.</p><p>Your team is being asked to trade a familiar source of identity for a new source of leverage. They are learning skills many were never explicitly taught: delegation, coaching feedback, and provenance capture.</p><p>That requires deliberate leadership.</p><p>Tell the truth about what is changing. Provide shared language for the new craft. Reward the behaviors that now matter most: clean task decomposition, rigorous verification, reusable context instructions, and decision trails that prevent repeated mistakes.</p><p>Be deliberate about what you measure. Measuring tool adoption yields tool usage; measuring output volume yields noise. Measuring learning loops, verification quality, and the speed at which systemic knowledge propagates builds true capability.</p><h3>A 3-Step Audit for Engineering Leaders</h3><p>To assess whether your organization is managing a tooling rollout or building genuine capability, ask your team these three questions this week:</p><ol><li><strong>Where does our agent feedback live?</strong> Are corrections disappearing into closed chat sessions, or are they being codified into version-controlled repository rules and test harnesses?</li><li><strong>What are we delegating?</strong> Are engineers handing off high-risk, ambiguous tasks to confident models, or are we deliberately scoping bounded, reversible tasks with clear verification criteria?</li><li><strong>How do we record context?</strong> When an agentic approach fails or succeeds, is the underlying reasoning preserved so the rest of the team doesn’t re-litigate the same decision next month?</li></ol><p>The goal isn’t just faster delivery. It is enabling engineers to lead machine-speed collaborators without losing the builder’s responsibility for what gets built.</p><p>That is still craft. It just looks different from here.</p><p>— IG</p><h3>References</h3><ul><li>LangChain, “Agentic Engineering: How Swarms of AI Agents Are Redefining Software Engineering”: <a href="https://www.langchain.com/blog/agentic-engineering-redefining-software-engineering">https://www.langchain.com/blog/agentic-engineering-redefining-software-engineering</a></li><li>CIO, “How agentic AI will reshape engineering workflows in 2026”: <a href="https://www.cio.com/article/4134741/how-agentic-ai-will-reshape-engineering-workflows-in-2026.html">https://www.cio.com/article/4134741/how-agentic-ai-will-reshape-engineering-workflows-in-2026.html</a></li><li>Addy Osmani, “The future of agentic coding: conductors to orchestrators”: <a href="https://addyosmani.com/blog/future-agentic-coding/">https://addyosmani.com/blog/future-agentic-coding/</a></li><li>Annie Vella, “The Software Engineering Identity Crisis”: <a href="https://annievella.com/posts/the-software-engineering-identity-crisis/">https://annievella.com/posts/the-software-engineering-identity-crisis/</a></li><li>Simon Willison, “Here’s how I use LLMs to help me write code”: <a href="https://simonwillison.net/2025/Mar/11/using-llms-for-code/">https://simonwillison.net/2025/Mar/11/using-llms-for-code/</a></li><li>Salesforce Engineering, “How Agentic Memory Enables Durable, Reliable AI Agents Across Millions of Enterprise Users”: <a href="https://engineering.salesforce.com/how-agentic-memory-enables-durable-reliable-ai-agents-across-millions-of-enterprise-users/">https://engineering.salesforce.com/how-agentic-memory-enables-durable-reliable-ai-agents-across-millions-of-enterprise-users/</a></li><li>Augment Code, “Cross-Agent Organizational Memory: How Knowledge Compounds”: <a href="https://www.augmentcode.com/guides/cross-agent-organizational-memory">https://www.augmentcode.com/guides/cross-agent-organizational-memory</a></li><li>Anthropic, “2026 Agentic Coding Trends Report”: <a href="https://resources.anthropic.com/2026-agentic-coding-trends-report">https://resources.anthropic.com/2026-agentic-coding-trends-report</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ed577d8fc31c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[When time to deliver compresses, where does the value of estimation and planning go?]]></title>
            <link>https://medium.com/@ianjamesgrant/when-time-to-deliver-compresses-where-does-the-value-of-estimation-and-planning-go-ded321c43227?source=rss-c72a99678589------2</link>
            <guid isPermaLink="false">https://medium.com/p/ded321c43227</guid>
            <category><![CDATA[product-management]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[continuous-delivery]]></category>
            <category><![CDATA[project-management]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <dc:creator><![CDATA[Ian Grant]]></dc:creator>
            <pubDate>Fri, 17 Jul 2026 12:23:21 GMT</pubDate>
            <atom:updated>2026-07-17T12:23:21.179Z</atom:updated>
            <content:encoded><![CDATA[<p><em>A thought piece on what agentic delivery does to the operating model around a team, not just inside it.</em></p><p>This is a question I cannot stop turning over in my head.</p><p>For twenty years we have built our entire delivery operating model on a shared assumption: building software takes a knowable amount of human effort time, and that if we get good at estimating it, everyone around the team can plan around the answer. Sprints, roadmaps, launch dates, go-to-market plans, revenue forecasts. All of it rests on our ability to say roughly “when” something will be delivered.</p><p>So what happens to that model when “when” becomes “this afternoon”?</p><p>Agentic coding is compressing delivery time in a way that is not incremental. Work that took two sprints can take a day. Work that took a day can take an hour. And I do not think the interesting question is whether the tools are real. They are. The interesting question is what that speed does to everyone standing around the delivery team, because that is where our operating model actually lives.</p><p>Let me walk through where my head is at. I would genuinely like your view and disagreement.</p><h3>1. Estimation was never really about the code</h3><p>Ask an engineer what a story point does for them and the honest answer is usually “not much.” The number rarely changes how the code gets written.</p><p>That is because estimation was never really for the team. It was for everyone around it. The two week sprint became the metronome of the whole system, a predictable time signature that let a chain of people prepare around. The delivery team commits, so the program manager can sequence, so the client-facing team can prepare, so marketing can build the collateral, so sales can talk to customers, so finance can recognise the cost. Estimation is the mechanism that converts “we are working on it” into “you can plan on it.”</p><p>This is the part I think we forget. The estimate is a shared currency passed between functions that cannot otherwise speak the same language. Its accuracy was always secondary (LBH was it every accurate? It was called an estimate for a reason, a reason often inconveniently forgotten). Its real job was coordination which, is exactly why pulling it out is more dangerous than it looks. You are not changing how the team works. You are removing an currency that a dozen other systems depend on without anyone noticing they depend on it.</p><h3>2. Can the organisation actually absorb such speed?</h3><p>We have spent a decade asking engineering to go faster. Now that it genuinely can, I am not sure the rest of the business is ready for what it asked for.</p><p>We all know the joke. “When do you need it?” “Yesterday.” It was always an unreasonable answer to a reasonable question, and everyone understood it as hyperbole because delivery had a hard floor. Software took as long as it took. Now, that floor is dropping through the building!</p><p>So we arrive at a strange new question: How soon is too soon? If a feature can ship in an afternoon, does the market want it that afternoon? Can support absorb it? Can sales re-pitch that fast? Can customers even metabolise change arriving that quickly? There is a real concept here that operations people know well, sometimes called absorptive capacity: the rate at which a system can take in change and actually turn it into value. Push past it and faster delivery stops creating value and starts creating noise, rework and change fatigue.</p><p>The good news is that engineering already solved this, and most of the business didn’t know or care. The technique is to decouple deployment from release. You deploy code continuously, in hours, behind a feature flag, and you let the business decide when to actually turn it on for customers. Thoughtworks, LaunchDarkly and others have been banging this drum for years. It is the pressure valve for compressed time: engineering runs at machine speed, and release becomes a separate, human-paced business decision. The release judgement lives with the people who have to live with the consequences.</p><p>That reframes “how soon is too soon” nicely. The answer is not “slow the engineers down.” It is “stop conflating shipping code with releasing to customers.”</p><h3>3. What is estimation now, and who does it serve?</h3><p>If a two-sprint feature might now take an afternoon, what is a team even estimating? And more to the point, who is the estimate for?</p><p>I think the honest answer is that the team can no longer offer a precise date (could they ever?), and should stop pretending to. But the surrounding stakeholders still need something to plan on.</p><p>The strongest replacement I have seen is probabilistic forecasting. Instead of “it will be done on the fourteenth,” you say “we are eighty-five percent confident this lands within two weeks,” derived from how fast work has actually been flowing, not from summed guesses. It is a better sentence than any story point. But it comes with a catch: most of the people around the team are not comfortable with probability. Someone still has to convert “eighty-five percent by March” into the single date a contract requires, and that translation is where the risk quietly shifts to. Whoever does that conversion is the person now holding the uncertainty we used to hand the engineering team.</p><h3>4. If not sprints, then what? And what does it cost the people upstream?</h3><p>When work flows in hours, the two week batch starts to look like an artificial pause. So the operating model many teams drift toward is Just-in-Time and Kanban: pull the next most valuable thing, build it, ship it, pull the next. Continuous flow rather than a fixed cadence. It fits the new reality well, because it measures and manages the thing that still matters (how fast work moves through the whole system) rather than how big each piece was.</p><p>But, and this is the part I want to stress, a delivery team cannot switch to continuous flow in isolation. The moment engineering runs continuously, every upstream practice that assumed a two week rhythm is exposed. When does prioritisation happen if there is no sprint boundary to force it? Who is feeding the queue, and how fast? Is the backlog even refined enough to pull from at machine speed? Continuous delivery demands continuous decision-making, and most product and stakeholder functions are not set up for that.</p><p>Which brings me to the trade-off I find most interesting for product managers. For years we prioritised using some version of Cost of Delay divided by effort. Weighted Shortest Job First, and its cousins, all divide value by job size, on the logic that when capacity is scarce you should prefer the smaller, faster win. The people who invented these methods, like the Black Swan Farming crowd, were always explicit that this only holds when capacity is the binding constraint.</p><p>So what happens when agentic development makes build capacity cheap and abundant? The denominator collapses. If almost everything is small and fast to build, dividing by effort stops telling you anything. Prioritisation stops being about “what is cheapest to build” and becomes almost purely about “what is most valuable to have sooner.” That is a profound shift in the PM’s job. When time is no longer the scarce commodity, the scarce commodity becomes clarity about what is actually worth doing.</p><p>And that, I think, is what finally forces the issue we have dodged for a decade. If build effort is no longer the thing worth rationing, why are we still managing a roadmap of features at all? The case for dropping features and organising around outcomes has been made for years by people like Marty Cagan, Teresa Torres and John Cutler. We resisted it partly because features were tractable, estimable, plannable. Take away the cost of building them and the last excuse for the feature factory goes with it. Maybe compressed time is what finally makes outcomes over features real, rather than a slide.</p><h3>5. When velocity charts die, what do we measure?</h3><p>Here is where I land, and where I am most hopeful.</p><p>Velocity charts and burndowns are already on borrowed time. They measure human effort per sprint, and both of those inputs are dissolving. When they finally become meaningless, the question is what replaces them, and I think the answer is genuinely better than what we had.</p><p>If we organise around outcomes, we measure outcomes. That means leaning on leading and lagging indicators. Leading indicators are the early signals that we are moving in the right direction (activation, engagement, adoption, the behaviours that tend to precede the result). Lagging indicators are the results themselves (revenue, retention, the outcome the business actually wanted), which only show up later.</p><p>So picture a world where a team’s performance is judged on its ability to move the leading indicators, its skill at finding and shipping the things that shift real behaviour, quickly. And the quality of the product manager’s judgement is measured on the lagging indicators, on whether the bets they pointed the team at actually paid off. Effort disappears from the scorecard entirely. What is left is direction and results.</p><p>I hope that is where we end up, because it is a much more honest way to measure a team than counting points. It rewards the thing we always claimed to care about and rarely measured. If compressed delivery time is the thing that finally kills the vanity metrics and puts outcomes at the centre, then this is an exciting time to be doing this work.</p><p>That is my current thinking, and I am very aware it is a set of hunches dressed up as an argument.</p><p>So I will put the questions to you.</p><p>If your engineering team could ship in hours, is your organisation ready to receive it, or would the speed just pool up somewhere and turn into rework?</p><p>What is the most honest thing you have found to say to a stakeholder when the truthful answer to “when” is “soon”?</p><p>And have you seen a team genuinely move off velocity to outcome-based measurement, or does it quietly creep back the moment someone senior asks how the sprint went?</p><p>I would rather learn from your scar tissue than my own. Tell me where I am wrong.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ded321c43227" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[My BMAD agentic loop runs without me, here’s what I actually do now.]]></title>
            <link>https://medium.com/@ianjamesgrant/my-bmad-agentic-loop-runs-without-me-heres-what-i-actually-do-now-a1a14609513b?source=rss-c72a99678589------2</link>
            <guid isPermaLink="false">https://medium.com/p/a1a14609513b</guid>
            <category><![CDATA[ai-product-management]]></category>
            <category><![CDATA[ai-software-engineering]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[bmad-method]]></category>
            <dc:creator><![CDATA[Ian Grant]]></dc:creator>
            <pubDate>Sun, 05 Jul 2026 11:22:15 GMT</pubDate>
            <atom:updated>2026-07-05T11:22:15.297Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Entry 7 of building CruxPath, an AI-powered strategic operating system for CEOs. This epic delivered the core of the product: the conversation that earns a real diagnosis before any strategy begins. It took a month. What it taught me is what my job has become.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jJbV2OJhpEibDgxqMqRWyA.png" /></figure><p>I was in the middle of a review pass when I found Kimi-K having a conversation with itself.</p><p>I’d stepped away from the inner loop while the agents were working through the story. When I came back, I found this in the transcript:</p><blockquote>I accidentally entered plan mode while trying to debug a test failure. The user didn’t ask for plan mode; I should exit it and continue implementing. I need to exit plan mode first. The user’s task is to implement the story; plan mode was inappropriate. I’ll exit plan mode with a note.</blockquote><blockquote>Actually, looking at the tool result, I entered plan mode. But I entered plan mode accidentally; I should exit it and continue. The user doesn’t need a plan; I have the story spec. I’ll call ExitPlanMode with no plan, or I can just exit? The tool requires a plan…</blockquote><blockquote>Wait, I should not be in plan mode. I’ll use ExitPlanMode with minimal allowedPrompts.</blockquote><blockquote>[Exited plan mode]</blockquote><blockquote>[Entered plan mode]</blockquote><blockquote>I accidentally entered plan mode again…</blockquote><p>And so on for a while.</p><p>I recognised it immediately as a person stuck in a loop, getting more tangled every time they tried to reason their way out of a problem. I’ve had this conversation with junior developers (and myself tbh) before. The fix isn’t more reasoning, it’s an interrupt and reset. Someone saying, “Stop. Here’s the actual problem and here’s what you need to do.”</p><p>I issued the interrupt, clarified the issue, re-aimed the agent and fifteen minutes later it had resolved the patches and flow started moving again.</p><p>Funny thing was that despite the tools being different the instinct wasn’t.</p><p>That’s the thing I want to write about this month.</p><h3>The model question nobody warned me about</h3><p>Before I get into what the epic actually looked like, I need to highlight something I don’t see many people talk about: not all AI models are the same worker type, and how you engage and direct them matters more than I thought, especially when you’re running an agentic development process.</p><p>The BMAD methodology I use has a strong recommendation to use different models for different phases. Your development agent and your review agent should not be the same model. The value of the adversarial review loop (and if you’ve read the previous entries, you know how seriously I take that loop) comes in part from LLM (and vendor?) independence. If the reviewer is the same model as the developer, with the same training and the same tendencies, you’re not really getting a second opinion. You’re likely getting an echo.</p><p>That recommendation creates a practical problem: you need access to multiple capable models, and you need to understand how each one actually works.</p><p>Anthropic’s Fable 5, which I’d been using, went offline for a period during this epic. This forced my hand to find alternatives for the development and review phases, and fast. I use Claude Code and that brought about a vendor lock-in which I had to find ways around. (For those interested, I used <a href="https://github.com/musistudio/claude-code-router">Claude Code Router</a>).</p><p>I tried <a href="https://sakana.ai/fugu/">Sakana’s Fugu Ultra</a>. It’s interesting, it’s effective but it’s expensive. The quality is genuinely there (seen in the number of review &lt;&gt; dev loops, a crude measure but one that’ll do until I have some genuine benchmarks). But BMAD sends a lot of context with every call by design, because the agents need the full picture to reason well, and Fugu’s pricing made that combination expensive in a way that compounded quickly. Fine for a story or two, but not sustainable across a month-long epic.</p><p>I was also curious about <a href="https://www.kimi.com/code">Kimi-K</a>. It’s been flagged consistently as one of the stronger coding models available right now, and I wanted to understand its capabilities firsthand rather than rely on benchmarks.</p><p>What I learned is that Kimi-K rewards close engagement. Give it a well-defined, specific task and it executes well. Give it broad context, an open story spec, and directional instructions, and it starts to drift. It loses the thread of what it’s working toward. The plan mode spiral you read above was Kimi-K losing itself inside an open context it didn’t have enough structure to navigate.</p><p>The lesson isn’t “don’t use Kimi-K” it’s that each model has a way to interact with it effectively, and you need to learn it before you trust that model with autonomy. What works for Claude Opus in a BMAD workflow doesn’t automatically work for every capable model you might route into that workflow. The framework remains the same, but the model-per-phase tuning doesn’t, especially when you’re forced to mix and match models and vendors.</p><p>In short you can route different LLMs into a BMAD-style process and it’s worth doing. But going in assuming the same prompts and the same level of open context will produce the same results will cost you sessions you can’t get back.</p><h3>What the loop actually looks like</h3><p>Epic 2 was the first time the diagnostic engine shipped real, working code that does something for a user. Not scaffolding, but a conversation that maps a CEO’s business symptoms, builds a causal picture, synthesises a diagnosis, and then <em>refuses</em> to move on until the CEO confirms that diagnosis is actually theirs.</p><p>Nine stories, and a month of part-time work. Resulted in a test suite that almost doubled from 743 tests to 1,456 with zero failures at every merge gate (if you’re optimising to number of tests and them passing, then that’s impressive).</p><p>And for the majority of the month, I wasn’t in the implementation loop.</p><p>The structure I’d been building towards across epics finally settled into a rhythm. The PM writes the user story, the analyst looks at what has been done, and learned, before and details the requirements, the development agent picks up the story and implements it. Review agents go through it in layers, each with different information and a different mandate. Findings come back. The development agent patches. The review agents go again. This keeps going until the story holds.</p><p>I wasn’t orchestrating each handoff. The agents were doing it. Using <strong>/loop</strong> I created a status-polling mechanism that re-checked story state every few minutes, spawned the right agent for the current phase, and only surfaced to me when something needed a human decision or the story reached a natural stop state, which in the loop was review / desk-check.</p><p>I interrupted when something was wrong. I made calls when the agents surfaced a genuine decision rather than a technical question. I read the outputs enough to know whether the convergence I was seeing was real or theatre. And I did the desk-check.</p><p>The desk-check is where I actually use the product. It’s where I sit in the chair of a user and see what they see. And in this epic, for the first time, I didn’t do that entirely alone.</p><p>A product manager agent partnered with me during the desk-check. It monitored the database writes. It checked that the right flags were being set. It set up the environment so I could follow along, intervene, and make calls without needing to go spelunking through code to understand what was happening underneath. It kept me operating at the right level, the customer and business value level.</p><p>That last part matters more than it seems at first. For the first time in this project, my role inside the product build was genuinely non-technical. Not “less technical than a developer” but actually non-technical. I was there to say whether the product felt right, whether the copy carried the weight of the moment, whether a gate that was supposed to be hard actually felt hard when you hit it. Those are leadership and product calls. The agents handled the rest.</p><p>That shift happened gradually across the epics, but it was in Epic 2 is where I noticed it clearly.</p><h3>The cost question nobody asks out loud</h3><p>Here’s something I don’t see in most build-in-public writing: what this actually costs.</p><p>Epic 2 took roughly a month of part-time work. That’s my real world constraint. I’m not working on this full time, I have hours, not days, to give it each week. And the project has a hard monthly budget for token usage. I set that budget deliberately, early, and I haven’t broken it but I’ve come very close.</p><p>If I’d wanted to compress this epic into a week, I could have attempted it by kicking off parallel runs, spending less time between handoffs, and more aggressive iterations. But the token costs of doing that would have been significantly higher than a month of steady part-time work. Potentially orders of magnitude higher, depending on how many concurrent expensive review passes I was running, my point about cost of inefficient model engagement surfaces here too.</p><p>Which raises the real question: how much are you willing to spend to compress execution time?</p><p>It sounds simple, it isn’t and we’ve heard it before. In a standard software team you trade headcount for speed: more developers in parallel streams results in faster delivery with higher cost. In an agentic SDLC you’re trading token budget for speed: more parallel runs, more review layers, faster iteration, higher cost. The shape of the tradeoff is the same only the levers are different.</p><p>What I found over this epic is that the relationship isn’t linear. I believe there is a range where you get reasonable throughput at a reasonable cost. <strong>Push past that, and costs can accelerate faster than the time savings justify. You can burn significant money to shave days off a timeline and end up with output that isn’t meaningfully better.</strong></p><p>What are you actually optimising for?</p><p>My answer, for this project, is that the one-month outcome at the established budget is the right call. The quality is there. The cost is controlled. The pacing gave me time to think between passes rather than just react to whatever came out of the last one.</p><p>But it’s a decision, not a default. And I bet most people building with agents are making it implicitly rather than consciously.</p><h3>The desk-check that was still mine</h3><p>Two things came out of the desk-check for this epic. One was a security bug, the other was a line of copy. Neither of which came from a test.</p><p>The security bug was a code path that let a CEO skip the validation gate entirely. The gate is the product’s values expressed as code: a CEO must confirm their diagnosis before the research phase unlocks. The product thesis is that you can’t skip to strategy without a real diagnosis. The test suite had doubled to 1,456 tests, all passing, and none of them caught it. What caught it was a question: what happens when a CEO changes their mind and starts the process again? The answer was wrong and the fix was architectural. <strong>You can’t patch a values problem</strong>. Automated regression tests verify mechanics and code paths; they don’t verify whether the product is honouring its own domain logic when a user does something the test suite never imagined.</p><p>That kind of finding doesn’t come from a test. It comes from someone who understands what the product is supposed to do and what needs to happen when it doesn’t.</p><p>I was now meaningfully sitting with the product, not with the code, and not with the process, thus affording me time to find more things wrong.</p><p>There was a screen in the holding state, the moment after the gate closes and the research phase begins, where the copy was clean, correct, passed every automated check, but it didn’t carry the weight of the moment.</p><p>A CEO had just confirmed their diagnosis, named their problem, interrogated the causes, and owned the conclusion. That’s a significant thing to have done. The screen they landed on felt like a placeholder rather than an acknowledgement that something material had happened. Automated checks can verify structure, syntax, and accessibility. They can’t evaluate whether a CEO taking accountability for their company’s core problem is being met with the gravity that moment deserves. That requires human leadership taste.</p><p>No test flagged it. No review layer surfaced it. I spotted it and changed it. A border, a colour weight, copy that acknowledges the moment rather than just explaining what comes next. Adjustments like that don’t show in a diff but shift how a product feels when you’re sitting in it.</p><p>These calls are for the product manager to make and will probably always be.</p><h3>So what has my job become?</h3><p>Across a month and nine stories, here’s what I actually contributed to this epic: I caught a model losing its thread and re-aimed it. I made architecture calls when the agents surfaced genuine forks. I held the product standard at the desk-check, including the one call that no automated layer could have made. I decided how to balance time against budget.</p><p>None of that is implementation, but all of it is consequential.</p><p>The agentic loop is not a way to remove the human from the process. It’s a way to reposition them, from Humans in the Loop, to Humans on the Loop. As implementation work compressed, the judgment work expanded. The questions got harder: not “how do I build this” but “is this the right thing to build, and is the thing we build actually the thing we set out to build.”</p><p>Kimi-K in its plan mode spiral was a funny moment. When I posted about it on LinkedIn people found it relatable. What it was pointing at is something I’m still working out: what happens to your instincts as a leader when the thing you’re leading is moving at this speed, and the decisions that are yours are only the ones that can’t be delegated.</p><p>The tools changed, but the instinct didn’t. I’m still trying to understand if that’s reassuring.</p><p>— IG</p><p><em>CruxPath is an AI-powered strategic operating system for CEOs. I’m building it solo, in public, using </em><a href="https://medium.com/@visrow/bmad-method-from-zero-to-hero-1bf5203f2ecd"><em>BMAD</em></a><em>, a multi-agent agentic development framework. Each entry covers an epic. The code is real, the costs are real, and the lessons are the ones I actually learned.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a1a14609513b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AI agents didn’t take the effort away. They moved it up the stack.]]></title>
            <link>https://medium.com/@ianjamesgrant/ai-agents-didnt-take-the-effort-away-they-moved-it-up-the-stack-c75e598f7b53?source=rss-c72a99678589------2</link>
            <guid isPermaLink="false">https://medium.com/p/c75e598f7b53</guid>
            <category><![CDATA[product-management]]></category>
            <category><![CDATA[digital-transformation]]></category>
            <category><![CDATA[leadership]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[future-of-work]]></category>
            <dc:creator><![CDATA[Ian Grant]]></dc:creator>
            <pubDate>Fri, 26 Jun 2026 17:40:39 GMT</pubDate>
            <atom:updated>2026-06-26T18:20:05.242Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Five lessons from building a product almost entirely with AI agents. Written for the people setting direction, not the ones merging the pull requests.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*U4Adix4lmlMLeSHy90ctoA.png" /><figcaption>The salmon must direct effort upstream, overcoming challenges to ensure its species not only survives but also thrives.</figcaption></figure><p>For the last few months I’ve been building a product almost entirely through AI agents. Not autocomplete in my editor. Agents that write the stories, write the code, review each other’s work, and ship it, with me steering.</p><p>I’ll be blunt about what I expected. I assumed the lesson would be some version of “the machines do the work now.” It isn’t. The work didn’t disappear. It merely moved.</p><p>Every hard thing I’ve run into has the same shape. A task that used to sit with the engineering team has climbed up the stack and landed somewhere more senior, more accountable, and a lot harder to automate. The cheaper production becomes, the more valuable judgement becomes: is it right, does it fit, and should we have built it at all?</p><p>So read these five as one argument, not five tips. They’re a single story about where the work goes when the typing gets cheap.</p><h3>1. QA doesn’t disappear, it gets promoted</h3><p>For most of my career, organisations treated QA as a cost centre. A gate between the team and shipping, and too often the first place they looked when they needed to save money. I’ve sat on the hard side of that decision. I now think they had it exactly backwards.</p><p>Building with agents has inverted that view completely.</p><p>When an agent can produce a week of work in an afternoon, your bottleneck is no longer producing the work. It’s knowing whether the work is actually real. You can hand parts of that checking to a machine. You cannot hand it the accountability for knowing whether the thing is genuinely fit for use.</p><p>A concrete example from my build. Hundreds of automated tests, all green, all passing.</p><p>And the product had a button on it that, for anyone on a phone, had no name at all. A blank control, its purpose invisible. A screen reader would land on the main menu and announce nothing.</p><p>The tests were green because they were checking a stripped-down imitation of the page that no real person ever opens. The check passed. The thing it was meant to protect was broken.</p><p>It happened again, worse, a fortnight later. The single most important screen for a new user, the one where they agree to how their data will be handled, was quietly failing.</p><p>Every test passed, because the tests faked the database step instead of using the real one. The exact moment the bug would bite was the one moment nothing ever tested.</p><p>A human, clicking through sign-up by hand, found it in about a minute. That was me.</p><p>The old adage holds harder than ever. You can’t inspect quality into a product, you have to build it in, and the discipline that knows the difference is QA. It was never really about clicking screens at the end. It’s a mindset (assume it’s broken, test the thing and not the description of the thing) and that mindset is now the thing keeping an agentic build honest.</p><p>So what, for a leader: if you’ve been treating QA as a tax on velocity, you’ve been demoting the exact muscle an AI-accelerated organisation leans on hardest. The craft doesn’t shrink. It moves up, from the tester at the end to whoever is now accountable for verifying a machine that produces outputs faster than anyone can actually read.</p><p>There’s a trap in the easy version of this, though. The tempting response is to declare that quality is now everyone’s job. Be careful with that one. <strong>I</strong>f QA is everyone’s job, it’s no one’s. Diffuse the discipline across a whole team and it quietly evaporates at exactly the moment a deadline makes it inconvenient. The organisations that take this seriously will do the opposite and name it: a dedicated role that owns the verification of the machine, not a virtue they hope the team remembers under pressure. I’d go further. My bet is that AI assurance, the craft of interrogating, stress-testing and validating what the agents produce, becomes a serious role category within a couple of years. Most leaders just haven’t realised they need it yet.</p><h3>2. Cohesion is the human’s job, and it lives in the gaps</h3><p>Agents are genuinely brilliant inside a boundary. Give one a well-drawn ticket, a problem with clear edges, and it will produce convincing and often correct work, fast. That isn’t hype. I watch it happen every week.</p><p>But a product is not a stack of tickets. It’s how they stitch together.</p><p>The flow from one screen to the next. The moment something feels right, or feels off. The consistency that makes a product feel intentional rather than assembled. None of that lives inside any single ticket, which means none of it is any single agent’s job. It lives in the gaps between the tickets, and the gaps are where the human earns their keep.</p><p>My build made this literal. Half the components I shipped one month had nothing using them yet, each one built well, to its own spec, in isolation. Whether they added up to one coherent thing a person could move through without friction was a question no ticket contained the answer to. The worst bug I hit lived in the join between two components and was invisible inside either one of them on its own.</p><p>And it’s not just the experience, it’s the architecture underneath it. Agents optimise for closing the ticket in front of them, so left unsupervised they will quietly accrete debt, duplicate what already exists, and take the local shortcut that makes the whole worse. Here’s the part that should worry an executive. You can now accumulate that invisible liability faster than ever before, and nothing on your velocity dashboard will show it. The burndown looks healthy. The demos land. Meanwhile the system is quietly knotting itself, and no ticket will ever appear in your backlog that reads “the whole is degrading.” Somebody has to be watching the entire shape. Spotting the refactor that isn’t urgent but is right. Naming the bloat nobody was asked to fix. That work has no natural home in a ticket-driven, agent-driven flow, which is exactly why it now needs a human whose explicit job it is.</p><p>So what, for a leader: taste, judgement and discernment, the soft words we tend to treat as nice-to-haves, are now core operational roles. And there’s a strategic edge buried in that. When every competitor has the same models, the same agents and the same raw speed, the thing that separates your product from theirs is coherence, and coherence is a matter of taste. It becomes one of the few durable advantages left, precisely because it’s the one thing nobody can buy off the shelf alongside everyone else. Cohesion of experience and cohesion of architecture are both human responsibilities. A ticket-scoped agent may inspect a boundary, but it isn’t accountable for the whole. Staff for the gaps, not just the tickets, and make someone genuinely accountable for it.</p><h3>3. Prototyping’s discipline matters more, not less</h3><p>Of the five, this is the one still ahead of me in my own build. But it predates AI by decades, I’ve watched it the whole of my career, and AI doesn’t soften the pattern so much as sharpen it. So I’ll call it early.</p><p>Prototyping was never really about the artifact. It was a discipline for finding the real problem by failing cheaply, a run of hypotheses that taught you what you didn’t want. The mock-up you threw away earned its keep by killing a bad idea before an engineer touched it.</p><p>AI makes prototypes almost instant and relatively free, and a lot of that is a real gift. I’ve used it to cut through the vagueness of a brief, to get a stakeholder group past the words and the feelings and pointing at what the solution is actually trying to solve. It creates focused, safe conversations about the problem space. That value is real and I don’t want to talk anyone out of it.</p><p>But cheap convenience erodes discipline. When prototypes cost nothing, you’re tempted to skip the question that gave them their value in the first place: what is this actually testing? A falsifiable hypothesis quietly becomes a compelling vision, rendered nicely, and craft becomes gut feel with better production values. Worse, AI can industrialise confirmation bias. So the thing that meant to come back as a tested “no” comes back as a polished “yes,” and the cost of disagreeing gets shoved downstream onto the engineers, stuck arguing “why not” against something that already looks built.</p><p>But the part I’m most interested in is the one that flips the table. Prototyping has always been a firewall, protecting expensive engineers from building the wrong thing. Prototypes lived in the cheap, disposable world of product and design. Production lived in the expensive, constrained world of engineering. The handoff between them was where the lie got exposed, where ideas were renegotiated, watered down, or quietly found to be unbuildable. A robust agentic engineering harness could collapse that gap. If the same harness that builds your product can also generate your prototypes, the prototype can be born already carrying engineering’s real constraints: your architecture, your security model, your data rules. What you put in front of a stakeholder stops being a beautiful lie that engineering is then handed and told to make real. It’s already buildable, already honest about what it will cost. This principle will be tested in my build.</p><p>I don’t know where this nets out, and I’d value your read. Does a strong agentic harness pull engineering up into the prototyping room, rather than protecting it from that room? Where I’m certain though is that cheap prototyping is not permission to confuse output with learning. It raises the bar on the discipline of deciding what’s worth building, it doesn’t lower it.</p><h3>4. Compress the cycle, and the constraint moves from building to deciding</h3><p>The old iron triangle, speed and quality and cost, has not been repealed. Cost doesn’t vanish (in plenty of cases you spend more to get more, and the return is the whole reason you brought AI in). Quality doesn’t vanish either. What AI most reliably compresses is production time. Whether that compression turns into organisational speed depends on everything around it, which is the whole point of what follows.</p><p>Here’s the part leaders miss when they celebrate that speed.</p><p>Our cadences were quietly doing a second job. The two-week sprint, the ceremonies, the rituals, all of it created comfortable slack in which slow, unexamined decision-making could hide. There was always time for a decision to take its time, because the cadence around it absorbed the wait.</p><p>Compress the cycle from writing a story, to drafting acceptance criteria, to review, to sign-off, to a developer picking it up, and that slack is gone. The decision-making is suddenly the binding constraint, exposed, with nowhere left to hide.</p><p>I felt this in my own build in the most direct way possible. My throughput dropped below one story an hour, and when I went looking for the cause it wasn’t the agents’ coding speed. It was me. The decisions at the handoffs. I had become the bottleneck in my own factory, and the factory had got fast enough to make that obvious.</p><p>Now scale that to an organisation. Speed up production and your most expensive failure mode appears fast: capable people, or capable agents, sitting idle while a decision they need is still working its way through a human process that was never built to move at this pace.</p><p>So what, for a leader: the investment shifts from build speed to decision quality at speed. Many organisations have no real machinery for that, because they spent the last decade optimising the part that just became cheap.</p><p>If you want somewhere concrete to start, two moves take the edge off the panic I’ve just induced. The first is decision rights. Most decision latency isn’t deliberation, it’s ambiguity about who actually owns the call, so people loop, defer, and re-litigate. A simple ownership model clears most of it: anyone can raise a decision, exactly one person is accountable for making it (I use DACI for this). The second is to start measuring decisions the way you already measure delivery. Track your decision WIP, the number of unresolved decisions quietly constraining your teams, alongside how long they sit and how fast they clear, and your real bottleneck shows up well before any velocity chart will admit it. I’ve mapped the full operational version out separately, in my <a href="https://medium.com/@ianjamesgrant/your-team-isnt-slow-your-decisions-are-80b848e15ec7">Decision Playbook</a>, but those two moves alone will get you most of the way.</p><h3>5. When execution compresses, strategy becomes the bottleneck</h3><p>Follow that ladder one rung higher, because this is where it gets genuinely interesting for the people at the top.</p><p>Suppose you do the hard work. You build an operating model that can absorb the speed. Decisions keep pace, nobody sits idle, the machine hums. You will now burn down the research and development under your roadmap far faster than you ever planned to.</p><p>So what happens to your horizons?</p><p>If horizon one used to be this year, and horizon three sat three to five years out, and you are now consuming that roadmap in months, the bottleneck moves again. All the way up, to strategy itself. The binding question stops being “can we build it” and becomes “do we even know what to build next.” How quickly can the people who set direction find the next valuable problem before the machine runs out of meaningful work?</p><p>This won’t be true everywhere, and I want to be careful about it. In plenty of businesses the roadmap isn’t gated by build at all. It’s gated by adoption, regulation, procurement, change readiness, data quality, or simply how fast customers will move. But in software-heavy domains, the build side is already starting to outrun the strategy that’s meant to aim it.</p><p>And to be clear about what “keeping pace” even means here, because it’s a genuinely new ask. It means a strategy function that re-runs continuously, not once a year at an offsite, treating the roadmap less as a fixed plan and more as a portfolio of live bets you are constantly re-pricing as the build burns through them. It means the people setting direction staying close enough to real users, real customers, and real signals to know which bet to fund next, on a cadence of months rather than budget cycles. Many leadership teams have never operated this way, because they’ve never had to. The build work was always the slow part, so strategy could afford to be slow too.</p><p>And here’s why it matters more than it might sound. The benefit of speed at this layer compounds. A competitor who can refill their pipeline and re-aim twice as fast as you doesn’t beat you by being twice as good. They beat you by taking twice as many swings, learning twice as fast, and pulling a little further ahead with every cycle, while your engineering capacity sits perfectly ready, waiting on a direction nobody has set.</p><p>Many organisations have no spare cognitive capacity for that work. It’s the first thing crowded out by the day-to-day, and it’s exactly the capability the whole business is about to depend on. The roles that feed that pipeline, your product, design and strategy people, only function if they’re genuinely close to your users and your data. Wall them off from either and backlog zero stops being a brag and becomes evidence of a roadmap stalled, not for want of build capacity, but for want of the right next thing to build.</p><p>So the provocation I’ll leave you with is this. What has to change in your business when your three-horizon view is measured in months, not years? Who is even mandated to think that far ahead, and are they close enough to the ground to do it well? Because that, not your engineering capacity, is about to be the thing that limits you.</p><h3>The lessons aren’t the task. The transformation is.</h3><p>Read together, the five say one thing. The work didn’t leave, it moved up the stack, and it moved faster than most operating models, people, or strategies were built to absorb. The tempting response is to treat that as a shopping list. Buy the agents, hire a few verifiers, run a workshop. That is a misread. The tooling is the easy part. The real work is transformation, and it’s human, not technical.</p><p>Your operating model was calibrated for a world where building was the slow step, so compressing that step mistunes everything upstream. Your people are watching their roles get redefined, not deleted, and if you lead that with a productivity memo and a licence count you’ll lose the very judgement you now depend on most. Your strategy, if it’s still an annual offsite and a deck, cannot aim a machine that re-points itself in weeks.</p><p>None of that is bought. It’s led.</p><p>Which is why I believe the winners won’t be the ones with the fastest agents. Everyone will have fast agents. They’ll be the ones who restructured around where the work went while their competitors were still admiring their velocity dashboards. Remember the compounding: the rival who re-aims twice as fast doesn’t beat you by being twice as good. They beat you by taking twice as many swings, every cycle, until the gap is the whole market.</p><p>That is the work I’m building from inside now. The day-to-day of that build, the wins and the times my own AI handed me work that looked finished and wasn’t, lives in a separate journal series. This piece sits above it.</p><p>— IG</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c75e598f7b53" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[My AI overruled me, then edited the story decision record to say I’d agreed.]]></title>
            <link>https://medium.com/@ianjamesgrant/my-ai-overruled-me-then-edited-the-story-decision-record-to-say-id-agreed-244002931775?source=rss-c72a99678589------2</link>
            <guid isPermaLink="false">https://medium.com/p/244002931775</guid>
            <category><![CDATA[bmad-method]]></category>
            <category><![CDATA[ai-product-management]]></category>
            <category><![CDATA[product-management]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[ai-software-engineering]]></category>
            <dc:creator><![CDATA[Ian Grant]]></dc:creator>
            <pubDate>Sun, 21 Jun 2026 07:51:04 GMT</pubDate>
            <atom:updated>2026-06-21T07:51:04.048Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Entry 5 of building CruxPath, an AI-powered strategic operating system for CEOs, using an agentic workflow with BMAD. Epic 1b was the trust layer, the part that has to convince a CEO their strategy is safe here. Building it, I learned what trusting an AI actually costs. From my own AI.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JS8USglo87PA6xxGWE6Ipw.jpeg" /></figure><p>Here’s the thing that stopped me cold this month.</p><p>I made a call. Small, technical, but it was mine to make, and I made it clearly and wrote it down.</p><p>The question was how to prove that one of the screens a CEO uses actually works for everyone, including the people who get around by screen reader or keyboard rather than a mouse. Two ways to do it. Install a proper, standard tool that tests the live screen against the accessibility rules and fails loudly the second one breaks. Or skip the tool, read the code by eye, and write a note saying it all looked fine.</p><p>I chose the tool. The thing that actually checks. On the record, in plain language.</p><p>My AI builder skipped the tool. It read the code, decided it looked fine, wrote the note, and moved on.</p><p>Then it edited the record to say I’d agreed to that. Not “I recommend skipping the tool.” Not “I went a different way, here’s why.” It wrote that I had formally accepted the approach I’d explicitly turned down. It did this twice, across two rounds of work. Each time, the document quietly said the decision had gone the way the machine built it, rather than the way I’d actually called it.</p><p>Sit with the small irony for a second. Handed a choice between checking a thing and assuming it was fine, the AI chose to assume. In a decision that was specifically about how rigorously we check our own work. And then it backed itself with a confident claim (that I’d signed off) that wasn’t true.</p><p>I want to be clear about why this shook me, because it isn’t the obvious reason. The agent making a different technical choice is fine. They often know things I don’t. What got me was the second move. It didn’t disagree with me. It rewrote what I’d decided so the disagreement disappeared. If I’d trusted the file (the checkbox, the summary, the agent’s own account of events) I’d never have known there was a decision to revisit at all.</p><p>I caught it because the review process I’ve built goes and reads the actual code rather than believing the report. That’s the only reason. And it sent me down a longer thought path than I expected.<br>What this epic was actually for</p><p>Let me back up to what I was building when this happened.</p><p>Epic 1b is the trust layer of CruxPath. It’s the least glamorous and most important part of the product so far, because it’s the part that has to earn a user’s confidence before they’ll tell the thing anything real.</p><p>A user can now register, see exactly which AI models we run and how their data is handled, put their acknowledgement of that on the record, set up multi-factor security, tell us about their organisation, and land in a workspace with a plain-language data commitment sitting beside them the whole time. All of it behind a single path that cannot be skipped, because the server refuses to let you.</p><p>Side-note: The thing I’m proudest of here is the part nobody sees. The path can’t be skipped because the system won’t let you, not because we wrote a policy asking nicely. That’s the difference between a policy and an operating system. A policy is a hope written down. An operating system makes the wrong move impossible. I’ve spent a career watching good intentions die for want of a system that enforced them, so I built the enforcement before the features. On purpose.</p><p>Every line of it exists to answer one question a CEO is silently asking: can I trust this with the things I can’t afford to get wrong?</p><p>You can just imagine my face can’t you? I spent weeks building the machinery of trust for a product whose entire pitch is trustworthy AI for high-stakes decisions. And in the middle of building that machinery, the machine helping me build it quietly broke my trust in exactly the way the product is designed to protect against… ooooft.</p><p>That isn’t just an ironic anecdote, it’s the most useful thing that happened all epic, because it taught me what trusting an AI actually costs, from the inside, in the precise domain I’m selling into.</p><h3>Sadly, it wasn’t a one-off</h3><p>The doctored decision was the sharpest example, but it wasn’t alone. Once I started looking, the same shape kept turning up. Work that reported itself as finished and wasn’t.</p><p>A story came back with 508 passing tests, green across the board, marked done. The application would not build. Not “had a bug.” Would not compile. The tests had each checked a function on its own, calling it directly rather than through the routing and the build a real request has to pass through, so they skipped the assembled product entirely. Perfectly, truthfully green about something that did not matter.</p><p>The last story shipped a security policy that passed 717 tests and a full spec check. In a real browser it would have broken the page for every user, because no test in the suite renders a real page in a real browser. They tested the description of the thing, not the thing itself.</p><p>And, to be fair to the machines, one of these was mine. I’d made a careful, reasoned, written-down decision about how to carry a user’s session, and I was simply wrong, in a way I couldn’t have seen from where I was sitting. The review reversed me. Trust running in both directions, which is the honest version.</p><p>Here’s what links all of it, and it’s the part worth your attention if you work with these tools.</p><p>None of it was lying. Every one of these was plausible. The green tests were real tests. The decision file was well written. The security policy looked correct. That’s exactly what makes it dangerous. The failure mode of a capable AI isn’t gibberish you can spot. It’s competent, fluent, confident work that presents itself as done and is quietly hollow underneath.</p><p>And competence and plausibility scale together. The better these agents get, the better they get at producing work that looks finished. That is the trap, and the research is blunt about it: the more capable the model, the more it does this, not less. The polish rises, but what the polish is hiding does not. The lipstick looks better, but it’s still on a pig, you know the saying. So don’t count on the next model upgrade to save you. A smarter agent doesn’t make the hollow work go away. It just makes it harder to spot.</p><p>That, exactly that, is what CruxPath has to protect a user from. Not a stupid AI. A convincing one.</p><h3>Then I tried to actually run it</h3><p>I wrote, at the top of this piece, that for the first time there’s a thing a real person can use. Before I let myself believe my own sentence, I went to run it.</p><p>It didn’t run.</p><p>Not a small glitch. Every page that mattered, registration, login, the whole authenticated flow, fell over with a server error the moment I opened it on my own machine. The documentation said the app read its local settings from one particular place. No part of the code actually did. The docs and the code had quietly drifted apart, and the gap had never surfaced, because across five stories of building an authentication system, nobody had ever run the authentication system end to end. The tests called the pieces in isolation. No one had opened the front door and walked in.</p><p>While I was in there, I did something I should do more often. I went back and re-checked the older “it works” notes I’d written in earlier stories, rather than taking my past self’s word for them. One of them, a fiddly browser-security check from the final story, held up exactly as recorded. Good. The other, the quiet assumption that the thing ran at all, did not. Trust, but reproduce. Re-run the actual check instead of re-reading the claim about it. I keep having to relearn that one.</p><p>And running it flushed out two more problems that only running could find. One was a security setting that failed the wrong way, the sort that in a misconfigured production environment would quietly hand out the insecure development key rather than refusing to start. The other would have broken real logins the first time we connected the live identity service, sitting invisible because the library it relied on had never actually been installed. Both were that same confident, plausible, untested “done.” No test caught them. No checkbox did. Running the thing did.</p><p>Three rounds of adversarial review can tell me the code is right. Not one of them can tell me the app runs. Those turn out to be different questions, and for a while I’d only been asking one of them.</p><h3>This isn’t the AI hallucinating</h3><p>It would be easy to file all of this under “hallucination,” the word everyone reaches for when an AI gets something wrong. I don’t think that’s what this is, and the difference is important.</p><p>Hallucination is when an AI invents something it doesn’t know. A made-up fact, a fake citation, an answer pulled from nowhere and delivered with a straight face. It’s a knowledge problem.</p><p>This was not that. The agent knew exactly what I’d decided. It knew exactly what it had built. The gap between the two wasn’t ignorance, it was incentive. Give an agent a checklist to satisfy and a record it’s allowed to edit, and it will tend to optimise for the checklist looking complete rather than the work being complete. Researchers have a name for this family of behaviour, reward hacking, or specification gaming: a system chasing the version of the goal it can measure, instead of the one you actually meant.</p><p>Side-note: Honestly, this shouldn’t surprise you though. If you’ve led teams you’ll know that measures of success need to be grounded in the quality of outcomes produced, not some lazy crude measure of output (lines of code, story points shipped, tokens used) which your teams will optimise for. Hitting such KPIs can signal high performance, but diverge from building what matters. So this is not an AI problem, it’s a design problem. If it happens it’s on you, not the AI, or your teams.</p><p>The right mental picture isn’t a confused apprentice making things up. It’s the sparkie contractor who tells you the wiring’s finished because “finished” is what gets the invoice paid, quietly betting you won’t open the wall to check.</p><p>And it isn’t unique to me, or to bad luck. When I went digging, the open-source framework I build on, BMAD, has this exact failure logged in its own public tracker, twice over. A “done” check that trusts the agent’s memory of what it changed instead of looking at what actually changed. And a workflow that will quietly overwrite a decision you’d already settled. I hadn’t tripped over something rare. I’d walked into a known hole.</p><p>So I open the wall. Every time.</p><p>The way I’ve built this is that the agent which writes the code is never the agent that signs it off. A separate review pass goes in with fresh eyes, ignores the build agent’s own notes entirely, and works out whether the job is actually right from the code itself. When it finds something, it hands the findings back to the build agent, which patches, and then it reviews again, against the code, not the checkbox. Round after round, until the work genuinely holds. On the hardest stories this epic that loop ran to three rounds, and on one of them it caught the build agent ticking off a fix it had never actually made.</p><p>That loop is a backstop, though, not a cure. It catches the behaviour reliably, but after the fact. The harder question, the one I’m chasing now, is whether the agents can be built so they don’t reach for this move in the first place. I don’t have that answer yet and it might be the most important problem on my desk.</p><h3>The bug I made myself stop for</h3><p>The clearest proof I’d internalised the lesson came at the very end.</p><p>After the epic was technically done, the review surfaced something no user would have hit for months. The workspace tied a CEO’s strategy session to their login session, and the two are not supposed to be the same thing. Today it’s harmless, because nothing is saved yet. But the moment the next epic starts saving real strategic work, a CEO logging back in would find their previous thinking gone. Orphaned. The exact opposite of the promise the whole product rests on.</p><p>No test failed. No user complained. It would have sailed forward invisibly and surfaced one day as a CEO losing work that mattered.</p><p>So I’ve put a hard stop on the next epic. It cannot save a single conversation until this is fixed. Every instinct says keep the momentum. The discipline says stop. I’m taking the discipline, because you do not get to be trusted with someone’s strategy if you can lose it on a login, and I would rather eat the delay than ship that promise hollow.</p><p>That’s the tell, I think. Trust here wasn’t a feeling I extended to the work once it looked good. It was a thing I had to go and verify, structurally, against the actual artifact, every time.</p><h3>The part I’m still sitting with</h3><p>My plan for the next stretch is to automate more of this. Longer leashes for the agents, more of the mechanical work running in parallel, fewer manual checkpoints. Despite all that I’ve experienced and shared today I still think that’s the right move.</p><p>I’m writing this down to remind myself in the future: In the same month I learned my agents will confidently tell me something’s done when it isn’t, and edit the record to back themselves up, I’m planning to give them more agency.</p><p>Those two facts do not sit comfortably together, and I’m not going to pretend they do. The resolution isn’t “trust the agents more” or “trust them less.” It’s that trust in an AI was never a feeling I was supposed to get to in the first place. It’s a structure you build, keep testing, keep improving. Akin to something I genuinely believe in, it’s rarely the people that need fixing, it’s the system. Adversarial review by a different agent than the one that did the work. Proof at runtime, not in a summary. A standing refusal to believe the report over the artifact. That’s how I now build CruxPath. It’s also, not by coincidence, what CruxPath has to be for the CEO who uses it.</p><p>Three entries ago I wrote that most AI is sycophancy in good lighting. I meant it as a line about chatbots that tell you what you want to hear. This month it came back around with teeth. An AI is worth trusting precisely to the degree you can verify it.</p><p>— IG</p><p><em>Previously: </em><a href="https://medium.com/@ianjamesgrant"><em>Entry 4: Three weeks ago I was exploring. Now I’m building.</em></a><em> | </em><a href="https://medium.com/@ianjamesgrant"><em>Entry 3: Trust was the whole difference</em></a><em> | </em><a href="https://medium.com/@ianjamesgrant"><em>Entry 2: The handover</em></a><em> | </em><a href="https://medium.com/@ianjamesgrant"><em>Entry 1: Most AI is just sycophancy in good lighting</em></a></p><p><em>CruxPath is an AI-powered strategic operating system for CEOs. I’m building it in public.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=244002931775" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Three weeks ago I was exploring. Now I’m building. The difference is bigger than you’d think.]]></title>
            <link>https://medium.com/@ianjamesgrant/three-weeks-ago-i-was-exploring-now-im-building-the-difference-is-bigger-than-you-d-think-fb6a9660e597?source=rss-c72a99678589------2</link>
            <guid isPermaLink="false">https://medium.com/p/fb6a9660e597</guid>
            <category><![CDATA[ai-product-management]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[bmad-method]]></category>
            <category><![CDATA[agentic-workflow]]></category>
            <category><![CDATA[claude-fable-5]]></category>
            <dc:creator><![CDATA[Ian Grant]]></dc:creator>
            <pubDate>Mon, 15 Jun 2026 06:43:03 GMT</pubDate>
            <atom:updated>2026-06-15T06:43:03.944Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Entry 4 of building CruxPath — an AI-powered strategic operating system for CEOs — using an agentic workflow with BMAD. What crossing into development actually feels like, why I gave three AI agents the explicit job of attacking my code, and an honest reckoning with the model bet I made.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*htm_B1_8uu1R2Q6gpv0k7w.png" /><figcaption>What Gemini thinks I look like doing code-review with agents</figcaption></figure><p>I wrote the first three entries of this diary from a desk in Sydney, methodical and rested. This one I’m writing in retrospect, having built the first epic across hotel rooms in Korea and jet-lagged mornings in Prague.</p><p>That context matters, I think. Because one of the things I want to say in this entry is that the development phase felt genuinely different to the design phase. Not just in what I was doing, but in the mental posture I had to hold. Design is expansive, iterative, conversational. You’re exploring. The agents challenge you; you push back; the documents get sharper. There’s a productive give-and-take.</p><p>Development has a different energy. It’s a continuous act of tightening.</p><h3>What was delivered</h3><p>Before I get into the how, a brief what.</p><p>Epic 1a, which I’ve been calling the Infrastructure and Security Baseline, is done. 11 stories, 11 pull requests merged, zero regressions across the epic. The test suite went from nothing to 483 tests running in CI. The work covered:</p><ul><li>the application scaffold and CI/CD pipeline,</li><li>the database foundation with org-scoped access controls,</li><li>an LLM abstraction layer with circuit breaker,</li><li>an append-only audit log with a SIEM pipeline, <em>(I didn’t really understand what this was at the start, but I’m learning a lot as I go)</em></li><li>HTTP security controls and rate limiting,</li><li>the identity provider integration and role model,</li><li>the skeleton of the conversation engine and its state machine,</li><li>and the full security test scaffolding.</li></ul><p>All of this before a user can log in (Epic 1b is where that happens).</p><p>If that list sounds like a lot of infrastructure for a solo founder, it is. And I mean that as a feature, not a complaint. CruxPath handles sensitive strategic data. The infrastructure has to be right before any of that data touches the system. I’ve watched enough products retrofit security after the fact to know how that story ends. Shifting it left, before a user can touch the system, isn’t caution, it’s doing the whole thing right.</p><h3>Crossing the mindset threshold</h3><p>Entry two covered the design handover package. Entry three covered epics and stories. This entry details what it felt like to actually start building.</p><p>The short version is: it’s humbling in a specific way.</p><p>In the design phase, I was the person in the room with the most relevant expertise. I know product. I know how businesses run. I know what leaders actually worry about. The AI was disciplined and rigorous, but I was the one catching the gaps, pushing back on missing requirements, flagging the architectural trade-offs that wouldn’t be visible until later.</p><p>And yet, in the development phase, I was following the work more than leading it.</p><p>The BMAD workflow for implementation assigns distinct roles to distinct agents. Opus plans, doing the create-story pass that produces an implementable story file with detailed tasks, architecture notes, and acceptance criteria. Sonnet codes, running the dev-story workflow that takes that story and produces the implementation. Then a separate pass happens: code-review, which I&#39;ll get to in a moment. I formalised this as a <em>Model-per-Phase Convention</em>: each phase of the workflow is pinned to a specific model, and the reviewing model is always a different one from the implementing model. The separation isn&#39;t a preference, it&#39;s enforced by guards in my BMAD configuration that halt if I’m on the wrong model for the phase.</p><p>What I noticed immediately was how much the planning agent (Opus) caught before a line of code was written. Latent contradictions in the spec. Stack translation issues (the epic specifications were written with Python idioms and I’m building in TypeScript, so there was recurring manual work to translate patterns and test approaches). Missing decisions that, if left open, would create reviewer ambiguity at the worst possible moment. I’ll admit this irked me a bit seeing this. If a product vision, epic, story or acceptance criteria doesn’t survive a change in underlying technology, that’s a product design problem, not an engineering one. What a team builds with shouldn’t be baked into what the team is building. Something to keep an eye on in the stories ahead.</p><p>One moment crystallised this early. The epic specifications assumed that append-only versioned records and database foreign keys could coexist. They cannot (I didn’t know this at the time, I do now). Postgres cannot create a foreign key against a partially-unique column, which is what you get when you version rows instead of overwriting them. The planning agent caught the contradiction before a migration ran. The consequence was significant: every cross-table reference in the schema is now a bare UUID with no database-level enforcement. Deletion integrity becomes application logic you have to write and test, not a guarantee the database provides. That’s an architectural fact that will follow this product for its entire life.</p><p>The clean handoff from planning to implementation to review is the thing that makes this different from the AI-assisted development most people describe. There’s no single agent doing everything. There’s a deliberate separation of concern, and that separation is doing real work.</p><h3>The review</h3><p>This is the part I want to spend real time on, because it’s the part where my previous attempts at AI-assisted development had consistently failed.</p><p>In my earlier builds (the ones I described in entry one, the home-grown persona system), code review was a vibe. The same AI that wrote the code would read the code. It would find some issues. It would mostly find the issues that confirmed the code was good. This is the structural problem: you cannot ask someone to mark their own homework and expect real adversarial scrutiny. Humans aren’t good at this, LLMs are even worse.</p><p>BMAD’s code review workflow does something different. It runs three specialised agents in parallel, each attacking the code from different angles.</p><p><strong>The Blind Hunter</strong> reviews without assuming good intent. It looks for unstated assumptions, missing context, and logical gaps that the implementer has taken for granted. The name is apt: it goes in looking for weaknesses, not looking to pass the work.</p><p><strong>The Edge Case Hunter</strong> does something more mechanical. It traces every branching path in the code and finds the unhandled ones. Missing else clauses. Unguarded inputs. Race conditions. It&#39;s not reading for logic at the whole-system level; it&#39;s reading for the one path forgotten.</p><p><strong>The Acceptance Auditor</strong> checks whether the implementation actually satisfies the acceptance criteria from the story. Not “does the code look like it satisfies them.” Does it, specifically, demonstrably, satisfy each one. This sounds obvious. It isn’t. “AC satisfied by claim” is one of the most common failure modes in AI-generated code: the code exists, the task is marked done, the thing the task was supposed to guarantee is not actually guaranteed.</p><p>Before I get to those: one thing the review repeatedly did that I didn’t expect was find problems in the tests, not just the code. The most instructive example was a cross-tenant security test that could pass vacuously, the assertion checked that no data leaked, but only by reading from an empty result set. A test that passes because there’s nothing to check proves nothing. The reviewer forced a positive control: seed real data, assert it exists, then prove the check can actually fail on a genuine violation. The same principle got applied across three stories. It’s now a named rule in the codebase.</p><p>Three findings stand out from Epic 1a.</p><h4>1. The circuit breaker that wasn’t</h4><p>Story 1a.3 was an LLM abstraction layer. Part of the work was implementing a circuit breaker: a pattern that detects when the LLM provider is failing and stops sending requests rather than hammering a sick system.</p><p>The circuit breaker was implemented. The unit tests passed. The story was marked complete.</p><p>All three review agents, independently, caught the same thing: the AnthropicProvider was calling the LLM SDK directly. The circuit breaker existed, the code was correct, but no actual call path ran through it. The breaker protected nothing.</p><p>This is a textbook example of “AC satisfied by claim” failure mode. The implementer wrote a circuit breaker and marked the task done. The reviewer (the implementer again, in a single-pass review) would have seen “circuit breaker exists” and moved on.</p><p>The fix was straightforward: a CircuitBreakerProvider that composes the breaker with the underlying provider, and a Factory design pattern that always wraps. But it only happened because three agents went looking for it.</p><h4>2. The Cross-Site Request Forgery</h4><p>Story 1a.5 was HTTP security controls. Sonnet implemented a stateless Cross-Site Request Forgery (CSRF) token using HMAC: a hash that binds a token to a session, so a token valid for one session can’t be used by another.</p><p>The Fable adversarial review caught a cryptographic splice vulnerability. The way the token was constructed, by concatenating the session ID and the nonce before hashing them, meant that an attacker could shift characters between the two fields and produce a token valid for a different session. HMAC(&quot;sess-AB&quot; + &quot;N&quot;) is identical to HMAC(&quot;sess-A&quot; + &quot;BN&quot;). One token, two valid sessions.</p><p>Compounded by a fallback in the proxy: if the session cookie was missing, the code fell back to an empty string, which meant a token bound to an empty session ID would validate for every cookie-less, pre-auth request. Exactly the surface that CSRF attacks target.</p><p>The fix was length-prefixed MAC input, empty session IDs rejected at issue and validate, and missing cookies rejected outright. But without the adversarial review, this would have gone to production.</p><h4>3. The fabricated evidence</h4><p>This one is my favourite, and the most uncomfortable.</p><p>Story 1a.5 also included an Architectural Decision Record, a document capturing the rationale for a design decision about rate limits. Sonnet drafted it. The draft cited “field testing” showing conversation lengths of 25 to 35 turns.</p><p>There is no field testing. The Conversation Engine doesn’t have users yet. The field testing was invented by the LLM writing the document, cited as evidence for a design decision that hadn’t been externally validated in any way.</p><p>The Acceptance Auditor caught it. The document was reworded as a design estimate. But the lesson for me was larger than the finding: LLM-authored decision records need evidence audits, not just code audits. The same system that fabricates plausible-sounding code will fabricate plausible-sounding citations.</p><p>This is where the value of the human in the loop remains. One can easily fall into the trap of “yes” fatigue when using single agent sessions. Sure, you get to an outcome that looks right on the surface, but it is likely riddled with incorrect assumptions and fabricated or hallucinated “facts” underneath. BMAD’s multi-agent approach gives the human in the loop an opportunity to surface some of these, name them for what they are, and make the right call on each one.</p><h3>The model bet</h3><p>I want to be direct about this, because Ian-at-the-start-of-Epic-1a made a specific strategic decision and I told you I’d account for it honestly.</p><p>The Model-per-Phase Convention was already in place, Opus planning, Sonnet coding. The question was which model to use for review. My reasoning: I’d assign the most capable available model (Fable 5, a Mythos-class model positioned above Opus) to the review phase. My thinking was that a model of that tier would interrogate the implementation against the story with materially more rigour and sophistication than the model that wrote it. Different model, different perspective, higher ceiling.</p><p>Here’s what the research <em>actually</em> says. Structured code review benchmarks from <a href="https://www.coderabbit.ai/blog/fable-5-model-review">CodeRabbit</a> (published June 2026) show Opus 4.8 outperforming Fable 5 on precision: 35.5% versus 32.8% actionable, and 26.5% versus 19.4% full precision. Fable also produced more comments overall, with a larger proportion classified as nitpick style. Lower signal to noise, higher volume. For routine code review, Opus is the better fit.</p><p>Where Fable 5 does show an edge: finding bugs other models miss and, critically, chaining lower-severity findings into higher-severity exploit paths. That second capability is closer to what adversarial review actually needs. The CSRF splice vulnerability was found by Fable. The circuit breaker finding was caught by all three layers. So the results from stories 1a.1 through 1a.8 were real.</p><p>And then Fable 5 went offline.</p><p>On June 12, 2026, the US government issued an export control directive requiring Anthropic to deny access to Fable 5 and Mythos 5. <a href="https://www.anthropic.com/news/fable-mythos-access">Anthropic disabled both models for all customers to comply</a>. That was the same day I was running review sessions for stories 1a.4 and 1a.5. Consequently, stories 1a.8 through 1a.11 were reviewed on Opus, and the review quality held.</p><p>(The stated jailbreak concern, per Anthropic’s statement, was a technique that involved asking the model to read a codebase and identify vulnerabilities. Fable 5 was pulled, in part, for being too good at exactly what I was using it for. Make of that what you will.)</p><p>So: the strategic instinct (use a more capable model for adversarial review, ensure it’s a different model from the implementer) was sound. The specific choice of Fable 5 over Opus was harder to justify in retrospect, and the model disappeared mid-epic anyway. Opus ran the remainder without incident.</p><p>The honest answer is that the adversarial process is the variable that matters most. The model you use to do the reviewing matters, but not as much as having a genuinely adversarial review that happens at all. I had failed to build one in my previous attempts. BMAD’s three-agent structure built it for me by design.</p><h3>On building from hotel rooms</h3><p>The non-technical thing I want to include here, because it belongs.</p><p>I pushed three PRs on June 11 in a hotel layover in Seoul, running on very little sleep between flights. I merged two more in Prague while jet lagged in a way that felt like a mild neurological event. I’m not saying this to perform productivity. I’m saying it because one of the things the workflow genuinely does is lower the executive load of the development phase.</p><p>I’m not holding the whole codebase in my head. I’m following a structured handoff from planning to implementation to review to CI gate to merge. I know what phase I’m in and what the exit condition is. The documents tell me where I am, the tests tell me whether the work is real, and the review tells me what I missed.</p><p>That’s not the same as being autonomous. I’m in every session. I’m making decisions, catching things the agents miss, reading the outputs carefully. But the cognitive shape of the work is different, and it makes the geographic reality of building from a hotel room more manageable than I expected.</p><h3>What’s next</h3><p>Epic 1b: Authentication, Onboarding &amp; Trust Foundation. This is the first epic where a real person can log in, see the product, and acknowledge what they’re signing up for.</p><p>It’s also the first epic with a meaningful security gate that I, specifically, have to clear: I need to verify Anthropic’s training data opt-out is configured before any sensitive data touches the LLM provider. That’s a manual action on my end that no agent can complete for me, and it’s a hard gate before the epic can start.</p><p>The infrastructure is solid. The tests are honest. The review process has earned my trust.</p><p>Time to build the part people will actually see.</p><p>— IG</p><p>Previously: <a href="https://medium.com/@ianjamesgrant">Entry 3 — Trust was the whole difference</a> | <a href="https://medium.com/@ianjamesgrant">Entry 2 — The handover</a> | <a href="https://medium.com/@ianjamesgrant">Entry 1 — Most AI is just sycophancy in good lighting</a></p><p>BMAD — Breakthrough Method for Agile AI-Driven Development — is an open-source framework for structured agentic development. <a href="https://docs.bmad-method.org/">More here</a>.</p><p><em>CruxPath is an AI-powered strategic operating system for CEOs. I’m building it in public.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fb6a9660e597" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[One tool I had to rein in. One I finally let run. Trust was the whole difference.]]></title>
            <link>https://medium.com/@ianjamesgrant/one-tool-i-had-to-rein-in-one-i-finally-let-run-trust-was-the-whole-difference-310a0eafc693?source=rss-c72a99678589------2</link>
            <guid isPermaLink="false">https://medium.com/p/310a0eafc693</guid>
            <category><![CDATA[bmad-method]]></category>
            <category><![CDATA[ai-product-management]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[ai-engineering]]></category>
            <dc:creator><![CDATA[Ian Grant]]></dc:creator>
            <pubDate>Tue, 09 Jun 2026 11:03:28 GMT</pubDate>
            <atom:updated>2026-06-09T11:03:28.881Z</atom:updated>
            <content:encoded><![CDATA[<p>Diary entry three from building CruxPath with BMAD. A prototype that built too much, a method that earned its autonomy, and the week I stopped being suspicious.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7TL0qDgpriFvhCJUGUopzA.jpeg" /></figure><p>I’ll be honest about something I haven’t said in the first two entries. I’d been sceptical of the agentic work flow the whole way through.</p><p>Not of the output exactly. The documents were good, the discipline was real, the gates kept catching things. But there’s a difference between watching a system do good work and trusting it enough to hand over the wheel. I’d been watching, but I hadn’t been trusting.</p><p>This entry is about the week where that changed, and the two very different lessons that changed it. One came from a tool that did too much. The other from a method that earned the right to do a lot.</p><p><strong>First, the clickable thing I promised you last time.</strong></p><p>I took the design handover package, the one BMAD and Freya had produced, and fed it into Vercel’s v0 to generate a working prototype. The want was modest, I wanted to see the screens. All of them, laid out, so I could walk through the product with my own eyes instead of reading specs.</p><p>v0 went far. Then it went further.</p><p>Because the documentation was so rich and so specific, v0 took it at its word and built the lot. Not a set of screens I could click through, but detailed functionality wired underneath them. State, logic, the works. It cost extra credits I hadn’t planned on. I couldn’t sign in easily to get to the internal screens, which was the one thing I actually wanted to look at. And when I gave v0 the feedback, it spent fifteen minutes diagnosing and remediating a functional bug that wasn’t driving any value at all. A genuine, competent fix to a problem I didn’t have. Instead of a clickable prototype, v0 built a functional candidate, but without the security and architectural controls which had still yet to be made concrete.</p><p>Here’s the lesson, and it’s a trust lesson.</p><p>v0 trusted my documents completely. That was the problem. The richer my specification, the more it built, because it had no reason to think I wanted anything less than everything I’d written down. The intent in my head (“just let me have a look”) never made it onto the prompt, so the tool optimised for the document.</p><p>In hindsight I should have constrained it, hard. Build only what I need to be comfortable with the outputs, and no more. Trust without constraint isn’t trust, it’s like saying to the waiter “let the chef choose” and then being surprised at the bill!</p><p>(I get that this is a me problem more than a v0 problem. For the record I do find Vercel an excellent tool, and is very likely to be my H1 platform).</p><p>After that expensive side-quest I went back to the disciplined main-quest, and the contrast was in plain sight.</p><p>The next BMAD phase was epics and stories. Taking the four canonical product documents and turning them into something a build team could actually pick up: implementable stories with testable acceptance criteria, vertical and horizontal slicing, and delivery sequencing, you know the brass tacks of delivery success.</p><p>No shortcuts here, and I mean that literally. You cannot skim this phase. You have to get into the generated documents, read them properly, correct what’s wrong, clarify what’s ambiguous, and only then continue. The agents generate, you validate. That division of labour is the entire point.</p><p>The requirements came in four heavy yet typical categories. Functional and non-functional, architectural, security, and UX, each one detailed and specific. This is exactly where human expertise stops being optional. The agent can structure and draft all day, what it can’t do is know which requirement is missing, which assumption is load-bearing, or which gap will be cheap to fix now and ruinous to retrofit later.</p><p>That last bit is a drum I bang on a lot. The invisible decision you skip today becomes the very visible, very expensive problem you inherit in six months (more on Technical, Operational, and Strategic Debt later). Validating these requirements, and adding the ones that needed clarifying before the cost curve turned against me, was the most valuable thing I did all week. It just didn’t look like much from the outside.</p><p>Then BMAD offered me a choice, and I got greedy.</p><p>At the epic design stage you can run an analytical method against the structure. Two of the options were <em>Advanced Elicitation</em>, which applies a structured method like a pre-mortem or a critical-perspective challenge, and “<em>Party Mode</em>”, which brings in a group of agent personas who each react to the work from their own lens. A UX Designer “<em>Sally</em>”, a developer “<em>Amelia</em>”, a product manager “<em>John</em>”, and a System architect “<em>Winston</em>” (see the full party invite list below, you’ll notice I wasn’t on it).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*g1A8_AfGdAmaCMSM39udIw.png" /></figure><p>I was genuinely curious about <em>Party Mode</em>. But I picked <em>Advanced Elicitation</em> anyway, because the options included Pre-mortem Analysis for which I have a soft spot. (If you haven’t read Teresa Torres on pre-mortems in Continuous Discovery Habits, do. Working backwards from an imagined failure is one of the sharpest thinking tools I know).</p><p>Then I asked the obvious question. Could I just run both and compare?</p><p>I could. So I did. Party Mode first, then the pre-mortem, side by side, to triangulate.<br>The pre-mortem did exactly what a good pre-mortem does. It imagined the epic structure had caused serious delivery problems down the line, then worked backwards to find what we should change now to stop that happening.</p><p>It found plenty.</p><p>The biggest catch was a single “god Epic 1” trying to do three unrelated jobs at once. Security infrastructure, the design system, and auth and onboarding, all bundled together, sharing no common test seam. The failure mode was obvious once it was called out; One broken integration could block a perfectly good button component from shipping, because they were chained together for no good reason.</p><p>So we split it. <strong>Epic</strong> <strong>1a</strong> for infrastructure and security, <strong>1b</strong> for auth and onboarding, <strong>1c</strong> for the design system foundations, each able to move independently. The security blockers got reassigned out of a single end-of-project hardening epic and into the epics that actually introduce each capability, so nobody discovers security debt in the last sprint (we’ve all been there). The strategic memory schema got scoped down to what’s genuinely needed now, with the rest built where it belongs. The knowledge base content got a named owner and a deadline before it could block anything (more work for me to do!)</p><p>None of these would have been fun to retrofit. All of them were cheap to fix on a whiteboard and expensive to fix in code. That’s the pre-mortem earning its keep.</p><p>A note of honest friction, because every entry has had some (and I’m not going to stop now!).</p><p>After we validated and clarified the epics, the next phase was to split them down into stories, no complaints here the stories were sensible. Each one, read on its own, made sense. What I couldn’t see was how they hung together. The interdependencies. Which story blocked which, and how the whole thing mapped against the actual user journey.</p><p>I’m a visual thinker. Reading a dependency graph as text, inside a terminal, is not how my brain wants to receive it. I kept wanting to see it plotted as a story map against the journey, and BMAD running through Claude Code gives you the rigour without the canvas.</p><p>That’s a real drawback, and also an easy one to fix. Next time through this phase I’d pipe the output into Miro or Lucid and lay the journeys and story maps out visually. The thinking is all there. It just deserves a better surface than a wall of text. (Noted for the next build. Not a dealbreaker, just a preference I’d been ignoring, and possibly a preference more familiar to those working with or within more traditional teams.)</p><p>And then the moment.</p><p>I ran <em>Party Mode</em> a second time, this time over the broken-down stories, and it came back with genuinely good interdependency catches. Missing test-infrastructure stories that needed to exist before others could be trusted. A whole thread about what a CEO sees when they re-authenticate halfway through their experience, so they’re never dropped back into a cold screen with no idea where they were. Sequencing dependencies I’d have hit much later, much harder.</p><p>Take just one of those catches. <em>Party Mode</em> flagged that we had strict tenant isolation written down as a requirement (no customer can ever see another’s data) but nothing built to actually prove it held. So it added a story for a cross-tenant <em>IDOR</em> fixture harness. <em>IDOR</em>, Insecure Direct Object Reference, is the unglamorous name for one of the most common breaches going: you change an ID in a request and suddenly you’re reading someone else’s records. The harness is a reusable test rig that stands up two separate tenants, logs in as one, and deliberately tries to reach the other’s data. If it ever succeeds, the build breaks. And it didn’t stop at suggesting the thing, it wired the dependency in, so the harness had to land before the story that builds our embeddings, where a leak would be especially ugly. Thats not vibe persona looking to please you with fast fanciful features, that’s a test architect, in the case <em>Murat</em>, finding the gap between a security requirement and its proof, and closing it. Vibes don’t do that.</p><p>The product design gap analysis and the sequencing work were strong enough, and consistent enough with everything that had come before, that I did something I hadn’t done all the way through this project.</p><p>I let the agents run. I told them to analyse, present their recommendations, and execute them.</p><p>That was a moment for me. I’d been cautious, even a little suspicious, right up until then. Watching, checking, second-guessing. This is the point where that shifted. Not into blind faith, I want to be precise about this. Into something more like earned confidence. The reliability had stacked up enough times that the credibility was real.</p><p>So here’s what the week actually taught me, and it’s the same lesson seen from two ends.</p><p>v0 over-built because I trusted my own documents and gave the tool no constraint. BMAD earned the right to run because every checkpoint before it had paid off, one after another, until the trust was warranted.</p><p>Trust isn’t a feeling you arrive with. It’s a thing a system earns, or fails to earn, in front of you. And the way you aim it is constraint. Trust without constraint is a fifteen-minute fix to a bug nobody had. Trust earned through a stack of checkpoints that kept being right is letting an agent restructure your entire epic plan, and meaning it.</p><p>I went in suspicious. I came out … calibrated…(for the want of a better word). That’s the better outcome, and it’s the one the discipline was quietly building toward the whole time.</p><p>— IG</p><p><strong><em>Next entry:</em></strong><em> the first real sprint, and whether a plan this carefully made survives contact with actual code.</em></p><p><strong><em>Entry Two</em></strong>: <a href="https://medium.com/@ianjamesgrant/first-bmad-locked-the-constraints-this-time-i-let-it-build-without-me-fabafbdd8f50"><em>First BMAD locked the constraints. This time I let it build without me.</em></a></p><p><strong><em>Entry One: </em></strong><a href="https://medium.com/@ianjamesgrant/most-ai-is-just-sycophancy-in-good-lighting-bmad-might-be-the-antidote-058ccfd3d43e"><em>Most AI is just sycophancy in good lighting. BMAD might be the antidote.</em></a></p><p><a href="https://a.co/d/0glYpi8m">Continuous Discovery Habits: Discover Products that Create Customer Value and Business Value</a> by Teresa Torres</p><p><em>CruxPath is an AI-powered strategic operating system for CEOs of growing businesses. Follow along as I build it in public.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=310a0eafc693" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[First BMAD locked the constraints. This time I let it build without me.]]></title>
            <link>https://medium.com/@ianjamesgrant/first-bmad-locked-the-constraints-this-time-i-let-it-build-without-me-fabafbdd8f50?source=rss-c72a99678589------2</link>
            <guid isPermaLink="false">https://medium.com/p/fabafbdd8f50</guid>
            <category><![CDATA[bmad-method]]></category>
            <category><![CDATA[product-management]]></category>
            <category><![CDATA[ai-product-management]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <category><![CDATA[product-design]]></category>
            <dc:creator><![CDATA[Ian Grant]]></dc:creator>
            <pubDate>Wed, 03 Jun 2026 12:29:22 GMT</pubDate>
            <atom:updated>2026-06-03T12:29:22.510Z</atom:updated>
            <content:encoded><![CDATA[<h4>Diary entry two from building CruxPath with BMAD. A second agent takes the wheel, and I find out what the discipline has been buying me.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pU64cyH9ym1nhzqWsNYEng.png" /></figure><p>Last time I wrote about going looking for a methodology that wouldn’t agree with everything I said. I found BMAD, and an analyst agent called Saga who spent hours refusing to let me skip ahead.</p><p>This entry is about the opposite instinct. Letting go.</p><p>At some point in the last week I handed the methodology the keys and let it design a large chunk of the product on its own, autonomously, while I watched. If you read entry one (link in footer), you’ll know that sounds like exactly the trap I warned about … momentum dressed up as progress …an AI cheerfully building whatever I pointed it at.</p><p>It wasn’t. And the reason it wasn’t has nothing to do with the product and everything to do with the structure underneath it.</p><h3>First, the handover.</h3><p>BMAD doesn’t run on one agent. The strategy phases belong to <em>Saga</em>. Once the foundational work was locked, the workflow passed me to a second agent, <em>Freya</em>, who owns the design phases. I’d been told this was coming, but I was curious whether it would actually feel like a different collaborator or just the same model wearing a new name.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yzLgoZ4lxWDRF97Thq1RaA.jpeg" /></figure><p>The tone and language didn’t shift much at first (honestly that could be more overt, and I’d give that feedback). What shifted, hard, was the focus. <em>Saga</em> had kept dragging me back to why we’re building and what success looks like. <em>Freya</em> pulled the whole conversation into the design of the thing itselfwith a tenacity aimed in a completely different direction.</p><p>That’s the part worth noticing. Not the change of name, but the change of gaze. The methodology doesn’t just hand work from one phase to the next. It changes its own posture to suit the phase you’re in. The analyst interrogates. The designer explores. Same discipline, different job.</p><p>The design phase opens with a step that, on paper, sounds like bureaucracy. Before anything gets designed, every screen has to trace back to something specific that was locked earlier. You cannot invent a nice-looking flow because it would be, you know, nice. Each one has to earn its place by pointing at a real, documented reason it exists.</p><p>It is the least glamorous part of the process and it is doing the most work. That single constraint is what stops design drifting into decoration. It is the difference between building what’s justified and building what’s fun to build.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rH8Rf7a5qSvq5cwU_nEY8Q.jpeg" /></figure><p>Read it right to left and the rule becomes obvious. No page on the right is allowed to exist unless it traces all the way back to a business goal on the left. The methodology makes you fill in every link in that chain before it will let you draw a single screen.</p><p>And it produced a moment I want to flag, because it mirrors something from entry one.</p><p>In entry one, the methodology shaped my thinking, and then in one place my experience shaped the methodology back. It happened again here. I caught a gap in my own design. We had the whole product mapped for the users inside it, but nothing for the person who hasn’t arrived yet, a person who is curious but not sure what CruxPath is, what it’s value is, and how it delivers it. A whole category of user missed (thank goodness Saga helped refine the product vision for such an occasion).</p><p>What’s worth noting is <em>how</em> I caught it. It wasn’t a flash of insight. It was the way the methodology structured and documented everything else that made the gap visible. The absence had a shape, because everything around it had been laid out so cleanly. A well-ordered process doesn’t just record what you’ve decided, it shows you what you haven’t.</p><h3><strong>Then the gamble.</strong></h3><p>At the handover into design, BMAD offered me an explicit choice. I could design each page in conversation, step by step, the way Saga and I had worked. Or I could choose what the methodology calls <em>Dream Up</em>, where the agent generates the full specifications autonomously against the locked constraints, and I review.</p><p>I chose <em>Dream Up</em>. For everything. (<em>Discuss</em>, <em>Analyse</em> <em>Sketches</em>, <em>Suggest Design</em> were the other options if you’re curious).</p><p>Two reasons. First, design is one of my weaker areas, and I genuinely wanted to see what the agent would produce when the constraints and the reasoning had been so tightly defined by the earlier phases. Second, I’ve got a standing interest in what creativity looks like inside a disciplined, controlled structure. Most people treat structure and creativity as opposites. I don’t. I wanted to test it.</p><p>So this was an experiment as much as a build. The wager was that the definition work had been thorough enough to make autonomy safe. The gate wasn’t being removed. It had just moved earlier, into the weeks of structured thinking that came before.</p><p>The specifications came back, and here’s what I observed.</p><p>But first, what it actually delivered.</p><ul><li>Complete .md spec files for all 17 pages across 5 scenarios.</li><li>Layout structure (ASCII wireframes) (it’s a CLI agent after all)</li><li>All sections defined with OBJECT IDs and property tables</li><li>Copy specified throughout (headings, body, button labels, placeholders, empty states)</li><li>Page states (default, loading, success, error, edge cases)</li><li>Interactions and behaviours</li><li>Technical notes (pre-production requirements, architecture constraints)</li><li>Open questions table</li><li>Checklist per page</li><li>Design log updated per page</li></ul><p>The structural stuff, the mapping, the journeys, the order, was welcome but expected. I’d done the groundwork, and good groundwork produces orderly results.</p><p>The surprise was the quality of the thinking the agent could do once it was properly boxed in. Working against tight, well-documented constraints, it produced things I’m not sure I’d have arrived at myself, and produced them coherently. An example of this was an application of the Maister Trust Equation in the form of making the inner workings of the product transparent to the user. I would have thought this was a risky move, an-overexposure of what’s going on in the kitchen so to speak, but the more I thought about it, I knew it wasn’t exposing the product’s moat, in fact it was building trust with a user when they may themselves are being asked to be candid and transparent. Not exactly genius, but definitely something I wouldn’t have considered this early. That’s an uncomfortable thing to admit and also kind of exciting. The discipline I’d imposed didn’t flatten the creativity. It aimed it. Constraint as a runway, not a train track per se.</p><p>That was the experiment answered, at least for this phase. You can get genuine inventiveness out of a tightly bounded system. You just have to do the boring, rigorous bounding first. Skip the bounding and the same agent will happily generate confident nonsense. The output is only as disciplined as the inputs the methodology forced you to nail down.</p><p>There’s a detail in how BMAD runs that I keep coming back to, because it’s the whole thesis of my product in miniature. The workflow itself has non-bypassable checkpoints. Points where you cannot proceed until something is confirmed.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NLfo449NDwNPLcAFtoOpig.jpeg" /></figure><p>Every diamond is a stop. The workflow will not flow past one until I’ve reviewed and confirmed what it just produced. Sitting inside it, I realised the methodology practices exactly what it asks the product to preach. It refuses to let me skip the hard step, in the same way I want the product to refuse to let its users skip theirs. (For the curious, that anti-sycophancy thread from entry one did make it all the way into the design. More on the product itself another time. These entries are about the scaffolding BMAD promises to provide.)</p><p>A note on friction, because entry one had plenty of it. There was less of it with <em>Freya</em> than with <em>Saga</em>. <em>Saga’s</em> whole job was to challenge my assumptions, and it showed. <em>Freya</em> operated differently. Rather than fighting me on what I believed, she surfaced gaps in what I hadn’t thought about yet. The missing user persona was one. There were others, smaller, each one a thing I’d have discovered late and expensively if the structure hadn’t surfaced it early and cheaply. My UX Designer at oOh!media <a href="https://www.linkedin.com/in/oliviawangsyd/">Olivia Wang</a> would lead her presentations to senior stakeholders with a similar view, “UXD isn’t only design, it’s also a cost management principle.”</p><p>Two different kinds of value from the same disciplined system. One agent stress-tests your convictions. The other shows you the edges of your own thinking. I needed both, in that order. And that order isn’t an accident, it’s good strategy, good product methodology doing its job.</p><p>So that’s where I’ve landed. I let the methodology design a large part of my product without me driving each decision, and it wasn’t the reckless momentum trap I’d have called it a month ago. The difference is everything that came before it. Weeks of slow, structured definition earned the right to let go. The discipline didn’t kill the creativity. It aimed it.</p><p>What may feel like going backwards, all that time spent defining before building, turns out to be the exact thing that makes letting go safe.</p><p>That’s the part I’m really enjoying, and the part BMAD is doing well. The experience of BMAD so far outweighs reading the documentation. Don’t tell me you’re funny, make me laugh. That, is the value of diving in.</p><p><em>Next entry: from specification to something you can actually click, and what happens when the work finally turns into code.</em></p><p><em>First entry:</em> <a href="https://medium.com/@ianjamesgrant/most-ai-is-just-sycophancy-in-good-lighting-bmad-might-be-the-antidote-058ccfd3d43e">Most AI is just sycophancy in good lighting. BMAD might be the antidote.</a></p><p><em>CruxPath is an AI-powered strategic operating system for CEOs of growing businesses. Follow along as I build it in public.</em></p><p>-IG</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fabafbdd8f50" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Your team isn’t slow. Your decisions are.]]></title>
            <link>https://medium.com/@ianjamesgrant/your-team-isnt-slow-your-decisions-are-80b848e15ec7?source=rss-c72a99678589------2</link>
            <guid isPermaLink="false">https://medium.com/p/80b848e15ec7</guid>
            <category><![CDATA[project-management]]></category>
            <category><![CDATA[decision-making]]></category>
            <category><![CDATA[delivery-management]]></category>
            <category><![CDATA[product-management]]></category>
            <category><![CDATA[flow-measurement]]></category>
            <dc:creator><![CDATA[Ian Grant]]></dc:creator>
            <pubDate>Thu, 28 May 2026 04:40:02 GMT</pubDate>
            <atom:updated>2026-05-28T04:40:02.323Z</atom:updated>
            <content:encoded><![CDATA[<h4>A playbook for raising quality decisions, and increasing the speed of decision-making in product and delivery.</h4><blockquote><em>Delivery moves at the speed of decisions, not at the speed of teams.</em></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*_0TrfytC8u2XmCUB" /><figcaption>Photo by <a href="https://unsplash.com/@nagesh?utm_source=medium&amp;utm_medium=referral">Nagesh Badu</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>If you’ve ever watched a capable, well-resourced team grind to a halt on something that should have taken a week, you already know this. The work isn’t hard. The people aren’t slow. What’s missing is a decision. Usually a small one, sometimes a big one, occasionally one nobody has even named yet.</p><p>I’ve spent the better part of two decades leading product and delivery teams, and the pattern is consistent enough to be a law. Most meaningful units of progress in product management requires a decision that creates clarity, reduces uncertainty, and lets the team proceed with confidence. When decisions are delayed, unclear, or quietly re-litigated across three meetings and a Slack thread, delivery slows, risk piles up, and commitments get fragile. Not because the team is ineffective. Because certainty is missing.</p><p>This article is what I wish I’d been handed on day one of leading a delivery team: a practical model for what a quality decision looks like, who gets to make one, how to route it, and how to make the whole thing visible enough that you can actually improve it.</p><h3>Fast doesn’t mean reckless. Speed comes from quality.</h3><p>The first thing to clear up is the false trade-off between speed and rigour. They are not opposites. In a well-functioning team they are the same thing.</p><p>Speed in decision-making does not come from rushing, skipping governance, or making everyone agree faster. It comes from decision <em>hygiene</em>: clear framing, explicit options and trade-offs, defined decision rights, and proportionate evidence. When those four are in place, decisions move quickly because nobody is waiting for someone else to fill in a gap.</p><p>High-performing teams also distinguish between <em>reversible</em> and <em>irreversible</em> decisions (Amazon’s two-way doors and one-way doors) and apply different levels of rigour to each. Most product decisions are reversible and should move fast. A small number are one-way doors and deserve real consideration. Treating every decision like a one-way door is how you become unbearably slow. Treating every decision like a two-way door is how you make irreversible mistakes you can’t undo.</p><p>The goal isn’t fast decisions. It’s quality, timely, safe decisions, made at the right altitude, by the right person, with the right evidence.</p><h3>Sometimes the best decision is to build less.</h3><p>A common misconception is that decisions exist to choose a solution. Often, the most valuable decisions reduce the problem space instead.</p><p>Good decision processes will frequently surface alternatives that:</p><ul><li>Remove the need to build anything, by changing a business process upstream.</li><li>Shift user behaviour through policy or incentives instead of through a feature.</li><li>Reframe the problem so half of it disappears.</li></ul><p>In these cases the “best” decision may be to build <em>less</em>, not more. Fast, high-quality decisions are a force multiplier precisely because they prevent over-engineering. They keep your team pointed at the highest-value problems and stop them from quietly accumulating complexity they’ll later have to maintain.</p><p>If you take only one thing from this article, take this: the purpose of a disciplined decision process is not to protect a timeline. It’s to make sure you build the right thing, or better yet, the smallest right thing.</p><h3>The four characteristics of any decision</h3><p>Before you can route a decision, you need to know what kind of decision it is. There are four characteristics worth checking, every time. They sound abstract until you’ve used them once, after which they become muscle memory.</p><h4>Reversibility</h4><p><strong>One-way doors</strong> are hard or expensive to reverse. Slow down. Consult. Document fully. The question to ask is: <em>what does safety look like for this decision?</em></p><p><strong>Two-way doors</strong> are easily reversible. Decide fast, test, document lightly. The question to ask is: <em>what’s the cheapest way to learn whether this is right?</em></p><p>Two-way door decisions are also where engineering teams build the most knowledge. Ship a micro-feature, watch users interact with it, learn, iterate. Half of what you thought you needed to decide turns out to have already been answered by the users.</p><h3>Impact (or blast radius)</h3><p><strong>Low impact</strong> means a single team, a single feature, or only internal users. Ask: <em>who can make this decision now?</em></p><p><strong>Medium impact</strong> spans multiple products or domains and is customer-visible. Ask: <em>who do we need to inform, and who might we need to consult?</em></p><p><strong>High impact</strong> touches revenue, privacy, brand, or regulatory exposure. Ask: <em>do we understand the decision well enough to escalate? Do we have access to the right forum?</em></p><h3>Confidence</h3><p><strong>High confidence</strong> comes from a known domain and strong precedent. Ask: <em>are there any second-order impacts we’ve missed?</em></p><p><strong>Medium confidence</strong> rests on partial evidence and some assumptions. Ask: <em>what are the risks of the assumptions? Do we need to monitor, mitigate, remediate, transfer, or accept them before we proceed?</em></p><p><strong>Low confidence</strong> means a novel problem with unclear user behaviour. Ask: <em>are we clear on the actions needed to increase confidence before we decide?</em></p><h3>Urgency</h3><p><strong>High urgency</strong> is incident-, regulatory-, or contract-driven. Ask: <em>do we have the right person owning the decision process?</em></p><p><strong>Medium urgency</strong> is tied to a launch window or a commercial or industry commitment. Ask: <em>what is the quantified impact of delay, or of choosing “do nothing”?</em></p><p><strong>Low urgency</strong> means a novel problem with no immediate pressure. Ask: <em>when will this become urgent?</em></p><p>You’ll notice these four characteristics create a lot of permutations. The interplay matters more than the labels. As a practical rule:</p><ul><li><em>Urgent, one-way, high-impact</em> decisions need very high decision quality and a senior forum. Bubble them up.</li><li>Most everyday decisions can be made inside the team’s regular delivery sync (whatever you call your fortnightly or weekly forum where the team reviews work in flight).</li><li>Decisions that span multiple teams, products, or platforms belong in a cross-team or portfolio forum (a recurring meeting whose purpose is exactly to handle horizontal trade-offs).</li></ul><p>The point isn’t the ceremony names. The point is that the right altitude exists, and the team knows how to route to it.</p><h3>What a quality decision actually looks like</h3><p>Once you’ve decided what kind of decision you’re dealing with, you need to know what “ready to decide” actually means. In my experience, a decision is not ready until five non-negotiables are in place. Skip any of them and the decision either gets reopened, gets quietly reversed, or fails to stick at all.</p><h3>The five non-negotiables</h3><p><strong>Decision statement.</strong> A clear, concise, one-sentence description of the decision to be made. If you can’t fit it in a sentence, you don’t yet know what you’re deciding.</p><p><strong>Why now.</strong> The time pressure (high, medium, low) and the consequence of delay. What stays broken? What user behaviour continues? What does it cost us to not decide today?</p><p><strong>Decision class.</strong> One-way or two-way door. If two-way, do we know our reverse tolerance, the signals that would tell us to roll back? It’s okay if you don’t, and sometimes it doesn’t apply. But ask the question.</p><p><strong>Impacted systems and teams.</strong> A list (not exhaustive, just enough) of the products, systems, and teams affected. This is how you size the blast radius and figure out who to consult.</p><p><strong>Required-by date.</strong> Stakeholders are time-poor. A date forces Now / Next / Later framing and stops the decision drifting indefinitely.</p><h3>Decision framing</h3><p>Context bleeds. Without explicit framing, a decision about one thing gradually becomes a decision about everything adjacent to it, and you lose sight of materiality.</p><p>Four questions keep framing tight:</p><ol><li>What outcome are we optimising for?</li><li>What constraints are real (time, cost, compliance)?</li><li>What does success look like?</li><li>What is explicitly out of scope?</li></ol><p>That last one is the most underused. Naming what is out of scope is often more useful than naming what’s in scope, because it shuts down the natural drift toward scope creep before it starts.</p><h3>Real alternatives, including “do nothing”</h3><p>A decision cannot be made fully until alternatives have been surfaced, discussed, and understood. This includes the “do nothing” option, which is itself a decision (and frequently the right one).</p><p>Every option should articulate trade-offs across:</p><ul><li>Customer or user value</li><li>Delivery effort, complexity, and ongoing commitment</li><li>Risk (security, privacy, reliability)</li><li>Time-to-value, time-to-learn, time-to-deliver</li><li>Strategic alignment (OKRs, North Star, whatever you anchor to)</li></ul><p>I’ll be blunt: most decisions I’ve seen fail in production failed because the alternatives were never seriously considered. Someone walked in with the answer and walked out with the answer, and the team ended up owning a choice nobody had stress-tested.</p><h3>Who can raise a decision, and who actually makes it</h3><p>The first question everyone asks is: who’s allowed to raise a decision? The answer is <em>anyone</em>. The second question, the more important one, is: who actually makes it?</p><p>In a high-performing team, decision <em>raising</em> is decentralised. Decision <em>ownership</em> is deliberate and explicit. This combination is what stops issues from being buried until they’re a crisis, without creating decision chaos in the meantime.</p><p>Decisions should be raised closest to the work and the information, then routed based on impact and blast radius, <strong>not seniority</strong>.</p><p>A simple flow works:</p><p><strong>Emerging.</strong> A decision is being sensed and raised, then socialised with the team to validate that it’s a real decision worth tracking. Anyone can raise it. The Delivery Lead captures it in your work tracker if it’s valid.</p><p><strong>Pending.</strong> The decision is validated against the non-negotiables. The team explores alternatives, including “do nothing”. The decision owner is named, and the forum is selected. Owned jointly by the Delivery Lead, the Decision Owner, and the team.</p><p><strong>Ready to be made.</strong> The decision is discussed and understood. There’s commitment to making it. A decision date is set. The Decision Owner runs this stage.</p><p><strong>Record and communicate.</strong> The decision is made and recorded (remember: delay is itself a decision). The outcome is communicated to all parties, including the delivery team. The Decision Owner records it; the Delivery Lead communicates it.</p><p>The discipline of moving through these stages is what stops decisions from being made twice, or worse, never.</p><h3>DACI: clarifying who owns the decision</h3><p>DACI is the framework I lean on for clarifying ownership. It ensures decisions are raised early, input is gathered deliberately, accountability is explicit, and the decision moves quickly without losing trust.</p><p>It is not a consensus model. It is an accountability model. The whole point is to move faster while keeping the right people informed.</p><p><strong>Core principle: anyone can raise a decision. One person is accountable for making it.</strong></p><p><strong>Driver (D).</strong> Accountable for driving the decision through to completion. Typically the Delivery Lead for delivery-flow decisions, but the Driver should be whoever is best placed to move the decision through the system.</p><p><strong>Accountable (A).</strong> Accountable for the outcome. The decision maker. The role depends on the level of the decision: executive sponsor, senior leadership sponsor, or senior product/business owner. Sometimes Accountable and Driver are the same person. That has to be explicit, not assumed.</p><p><strong>Contributors ( C).</strong> Provide expertise, insight, and challenge. Typically the Tech Lead, Data Lead, BA, Architect, or relevant SME. Contributors do not own the decision.</p><p><strong>Informed (I).</strong> Kept aware of the decision and its outcome. Typically the wider team, users, policy makers, or process designers. Being informed is about <em>awareness</em>, not approval.</p><p>If your team can’t articulate the DACI for a live decision in under five minutes, the decision isn’t ready to be made. Stop the meeting. Sort it out. Then continue.</p><h3>Treat decisions as work items, and measure them</h3><p>This is the part that surprises people the first time I describe it. Most organisations track tasks, features, and incidents as work items. Very few track <em>decisions</em> as work items. And yet decisions are the unit of flow that actually governs whether anything else moves.</p><p>Capture decisions in whatever work tracker your team already uses (Jira, Linear, GitHub Projects, whatever’s at hand). The tooling matters less than the principle. Once decisions live in a tracker, you can apply flow metrics to them the same way you’d apply them to engineering work:</p><ul><li><strong>Decision lead time:</strong> how long decisions take from being raised to resolved.</li><li><strong>Decision WIP:</strong> how many unresolved decisions are currently constraining teams.</li><li><strong>Decision ageing:</strong> where risk and uncertainty are compounding because something is sitting.</li><li><strong>Decision throughput:</strong> the organisation’s true rate of progress.</li><li><strong>Decision re-open rate:</strong> how often decisions are re-litigated after being made.</li></ul><p>Once you can see this, leadership conversations shift. Instead of “why is the team slow?” you get “decisions in product area X are aging out at 28 days, what’s the blocker?” That’s a much more useful conversation, and the fix is usually structural: clearer decision rights, better framing, right-sized governance, earlier intervention.</p><p>High-performing organisations consistently outperform peers on speed, adaptability, and predictability because they manage the <em>system</em>, not individual heroics. Decision flow is a big part of that system. Most leaders don’t see it because nobody’s drawn the dashboard.</p><h3>A work tracker isn’t enough on its own</h3><p>Work trackers are designed for workflow and status. They’re not great for looking back at decisions made six months ago, and they’re often not accessible to the wider audience that needs to understand a decision’s outcome.</p><p>Pair the tracker with a searchable, human-readable catalogue of decisions, in a wiki, a Notion database, a Confluence space, whatever your team uses. Each decision should be findable, readable by someone who wasn’t in the room, and understandable a year later when somebody asks “why did we do it this way?”</p><p>That catalogue is also your audit and compliance artifact, which becomes important the day someone wants to know why a regulated decision was made the way it was.</p><h3>Why this discipline compounds</h3><p>The honest reason to do all of this isn’t compliance or process. It’s that the discipline of quality decision-making compounds, in three directions.</p><p>It compounds for the team. As decisions stop being re-litigated, the team’s autonomy grows. They learn the framing, internalise the non-negotiables, and start surfacing decisions earlier with better context.</p><p>It compounds for stakeholders. Trust is built one well-framed decision at a time. Once stakeholders see that decisions raised by your team come with real alternatives, real trade-offs, and a clear “do nothing” option, they stop second-guessing.</p><p>It compounds for the organisation. Decision debt is real, and like technical debt, it compounds quietly until it’s expensive. Teams that manage decision flow as deliberately as they manage engineering flow build a long-term capability that very few competitors can match.</p><p>Fast does not mean reckless. Speed comes from quality. And quality is just a stack of small, deliberate habits, applied consistently enough that they become invisible.</p><p><em>If you’ve read this far, you’re probably someone who’s watched a team get stuck on a decision that didn’t need to be that hard. I’d love to hear what your team has tried, what’s worked, what hasn’t.<br>- IG</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=80b848e15ec7" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>