<?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 Levi Garner on Medium]]></title>
        <description><![CDATA[Stories by Levi Garner on Medium]]></description>
        <link>https://medium.com/@levi_garner?source=rss-53c9a3988c5e------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*h43UZKUoX2Tef-M8</url>
            <title>Stories by Levi Garner on Medium</title>
            <link>https://medium.com/@levi_garner?source=rss-53c9a3988c5e------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 03:53:29 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@levi_garner/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[I Built 12 Free Engineering Intelligence Tools.]]></title>
            <link>https://medium.com/@levi_garner/i-built-12-free-engineering-intelligence-tools-149db6c5da18?source=rss-53c9a3988c5e------2</link>
            <guid isPermaLink="false">https://medium.com/p/149db6c5da18</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[github]]></category>
            <category><![CDATA[engineering-mangement]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[engineering-intelligence]]></category>
            <dc:creator><![CDATA[Levi Garner]]></dc:creator>
            <pubDate>Thu, 23 Apr 2026 15:36:41 GMT</pubDate>
            <atom:updated>2026-04-23T15:36:41.614Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Grid view of 12 free engineering intelligence tools on intelig.ai/tools — Engineering Audit, Executive Summary, Org Comparison, Bus Factor, PR Benchmark, AI Code Attribution, Repo Audit, Velocity Tracker, Cost Estimator, Repo Health Check, Release Cadence, and Contributor Spotlight." src="https://cdn-images-1.medium.com/max/1024/1*E4NQzTMLwl1P5VBSoy6GCA.png" /><figcaption>All 12 tools, free, no signup required — intelig.ai/tools.</figcaption></figure><h3>Here’s What They Reveal About Your GitHub Org.</h3><p><em>By Levi Garner, Founder &amp; CTO of InteliG</em></p><p>For most of my career as a CTO, I kept running into the same problem every quarter. I needed clear answers to simple questions: what did engineering actually deliver, how much did it cost, and who was driving the most value.</p><p>Those answers existed, but they were scattered across Jira, GitHub, spreadsheets, and meeting notes. Pulling them together meant spending days digging through systems instead of actually leading the team.</p><p>When I started building InteliG, I realized something that shifted everything: the answers were never missing. They were sitting in Git the entire time. Every commit, every pull request, every change — all of it was already there. We just didn’t have a way to read it at the level leadership actually needs.</p><p>So I built 12 free tools to do exactly that. No setup friction, no onboarding flow — just paste a GitHub org and get real answers in under a minute. The goal wasn’t to build dashboards. It was to expose what’s already happening inside engineering, directly from the source of truth.</p><h3>1. Full Org Scan</h3><p><a href="http://intelig.ai/tools/scan">intelig.ai/tools/scan</a></p><p>This is the starting point. It gives you an immediate snapshot of your organization: a health grade, key findings, contributor distribution, and where your risks actually sit. Most teams go years without this level of visibility. This gives it to you in seconds.</p><figure><img alt="Full Org Scan results showing overall health grade A–F, key findings, contributor count, repo count, and risk exposure for a GitHub organization." src="https://cdn-images-1.medium.com/max/902/0*gWNKE8PVi8NyzXzQ" /></figure><h3>2. Executive Summary</h3><p><a href="http://intelig.ai/tools/executive-summary">intelig.ai/tools/executive-summary</a></p><p>This tool generates what most CTOs end up building manually for boards and investors. It pulls together velocity trends, risk signals, and a clear health score into something you can actually present. Instead of stitching together slides, you get a coherent narrative directly from your data.</p><h3>3. Cost Estimator</h3><p><a href="http://intelig.ai/tools/cost-estimator">intelig.ai/tools/cost-estimator</a></p><p>Most organizations understand their total engineering spend, but almost none understand cost at the execution level. This breaks it down into cost per commit, per pull request, and per contributor. Once you see engineering this way, it fundamentally changes how you think about efficiency.</p><figure><img alt="Cost Estimator results showing engineering cost per commit, per PR, and per contributor for a GitHub organization." src="https://cdn-images-1.medium.com/max/1024/0*7gNQpdWRR_-aciEh" /></figure><h3>4. Bus Factor Analysis</h3><p><a href="http://intelig.ai/tools/bus-factor">intelig.ai/tools/bus-factor</a></p><p>Every team has hidden concentration risk. A small number of engineers often carry a disproportionate amount of the system. This tool makes that visible immediately so you can address it before it becomes a real problem.</p><figure><img alt="Bus Factor analysis of Supabase showing top contributor concentration and key-person risk breakdown." src="https://cdn-images-1.medium.com/max/1024/0*jGnc8vilCVpYJ_HT" /></figure><h3>5. AI Code Attribution</h3><p><a href="http://intelig.ai/tools/ai-attribution">intelig.ai/tools/ai-attribution</a></p><p>AI is already shaping how code gets written, but most teams have no idea how much. This analyzes commit patterns and co-authorship signals to estimate how much of your codebase is influenced by AI tools like Copilot, Cursor, or Claude.</p><figure><img alt="AI Code Attribution scan showing percentage of AI-assisted commits, co-author signals, and bot patterns across a GitHub organization." src="https://cdn-images-1.medium.com/max/970/0*ojmHT0WAnLIyuaKw" /></figure><h3>6. Velocity Tracker</h3><p><a href="http://intelig.ai/tools/velocity">intelig.ai/tools/velocity</a></p><p>Instead of relying on abstract metrics like story points, this tracks actual delivery through commits and pull requests over time. The value isn’t just the number — it’s the trend. You can see whether your team is accelerating or slowing down before it becomes obvious elsewhere.</p><figure><img alt="Velocity Tracker chart showing weekly commit and PR volume trends over time for a GitHub organization." src="https://cdn-images-1.medium.com/max/1024/0*C98j3oW0Adpr48pB" /></figure><h3>7. PR Benchmark</h3><p><a href="http://intelig.ai/tools/pr-benchmark">intelig.ai/tools/pr-benchmark</a></p><p>Pull request flow is one of the most common hidden bottlenecks. This tool surfaces review time, merge rates, and rejection patterns so you can identify whether your process is slowing down delivery.</p><figure><img alt="PR Benchmark results showing cycle time, review speed, and merge rate compared to DORA Elite, High, Medium, and Low performance categories." src="https://cdn-images-1.medium.com/max/970/0*sjWH85W4Q6xVJdpE" /></figure><h3>8. Release Cadence</h3><p><a href="http://intelig.ai/tools/release-cadence">intelig.ai/tools/release-cadence</a></p><p>How often are you actually shipping to production? Not what the team thinks, not what the process says — what’s really happening. This is one of the clearest indicators of engineering health, and most teams don’t measure it accurately.</p><h3>9. Repo Audit</h3><p><a href="http://intelig.ai/tools/repo-audit">intelig.ai/tools/repo-audit</a></p><p>Over time, every organization accumulates unused and abandoned repositories. These create maintenance overhead and risk. This tool identifies what’s active, what’s stale, and what’s effectively dead weight.</p><figure><img alt="Repo Audit output listing abandoned repositories, naming duplicates, and a prioritized cleanup list for a GitHub organization." src="https://cdn-images-1.medium.com/max/970/0*47nClVH8BnwAdfWZ" /></figure><h3>10. Repo Health Score</h3><p><a href="http://intelig.ai/tools/repo-health">intelig.ai/tools/repo-health</a></p><p>This zooms in at the repository level, scoring health based on activity, contributor distribution, and development patterns. It’s useful for understanding where attention is needed across your system.</p><h3>11. Contributor Spotlight</h3><p><a href="http://intelig.ai/tools/contributor">intelig.ai/tools/contributor</a></p><p>One of the most common misconceptions in engineering leadership is equating visibility with impact. This tool focuses purely on delivery — who is actually shipping meaningful work — so you can understand where your real capacity sits as an organization.</p><h3>12. Org Compare</h3><p><a href="http://intelig.ai/tools/compare">intelig.ai/tools/compare</a></p><p>This allows you to benchmark two organizations side by side. Whether you’re evaluating an acquisition, comparing teams, or just trying to understand what “good” looks like, it gives you a grounded reference point.</p><h3>Why I Built These</h3><p>I didn’t build these tools as a growth tactic. I built them because I kept running into the same wall as a CTO. I was responsible for outcomes, but the systems I had access to didn’t reflect reality cleanly enough to make confident decisions.</p><p>Questions like “what did we actually deliver?” or “what’s our ROI per engineer?” shouldn’t require a week of analysis. The data already exists — it just isn’t structured in a way that leadership can use.</p><p>Git, however, doesn’t lie. It captures execution directly, without translation layers or manual updates. That’s what makes it fundamentally different from systems built on reported work.</p><h3>What This Actually Means</h3><p>These tools are just the surface layer. They show what becomes possible when you treat code as the primary source of truth instead of relying on secondary systems.</p><p>Once you connect commits to initiatives, meetings to decisions, and cost to actual delivery, you move from reporting on engineering to truly understanding it. That’s the shift InteliG is built around.</p><h3>Try It</h3><p><a href="http://intelig.ai/tools/scan">intelig.ai/tools/scan</a> <a href="http://intelig.ai/">intelig.ai</a></p><h3>Final Thought</h3><p>Most systems tell you what people say they did.</p><p>Git shows you what actually happened.</p><p>The future of engineering leadership will be built on that difference.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=149db6c5da18" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Jira Won’t Survive the AI Era — The Shift to Execution Intelligence]]></title>
            <link>https://medium.com/@levi_garner/jira-wont-survive-the-ai-era-the-shift-to-execution-intelligence-765f1188c31d?source=rss-53c9a3988c5e------2</link>
            <guid isPermaLink="false">https://medium.com/p/765f1188c31d</guid>
            <category><![CDATA[ai-tools]]></category>
            <category><![CDATA[engineering-leadership]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[developer-productivity]]></category>
            <category><![CDATA[project-management]]></category>
            <dc:creator><![CDATA[Levi Garner]]></dc:creator>
            <pubDate>Wed, 18 Mar 2026 17:03:40 GMT</pubDate>
            <atom:updated>2026-03-18T17:03:40.572Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Split comparison showing a traditional Jira board with stale tickets and manual status updates on the left versus an execution intelligence system on the right connecting Strategy, Code, Cost, and Outcome with Cognis AI answering whether the team is actually executing on what was planned" src="https://cdn-images-1.medium.com/max/1024/1*QPrVQ0RfW4te5rybeqgcZg.png" /><figcaption>Planning work vs Understanding execution</figcaption></figure><p>For the last 15 years, engineering organizations have been built around one core assumption:</p><p>Humans are the source of truth.</p><p>That assumption shaped everything:</p><ul><li>Jira tickets</li><li>Sprint planning</li><li>Story points</li><li>Status updates</li><li>Velocity charts</li></ul><p>All of it exists to answer a simple question:</p><blockquote>What is the team working on?</blockquote><p>But there’s a problem.</p><p>Most of that data is manually created, delayed, and often wrong.</p><p>And now we’re entering a world where that assumption no longer holds.</p><h3>The Fundamental Shift</h3><p>AI doesn’t rely on what people <em>say</em> they’re doing.</p><p>It operates on what actually happened.</p><ul><li>Commits</li><li>Pull requests</li><li>Code changes</li><li>Reviews</li><li>Deployments</li><li>Meetings, decisions, and action items</li></ul><p>This is the real execution layer of an engineering organization.</p><figure><img alt="Two-column comparison showing the human layer (Jira tickets, sprint planning, story points, status updates, velocity charts) versus the execution layer (commits, pull requests, code reviews, deployments, decisions and meetings)" src="https://cdn-images-1.medium.com/max/1024/0*wvAMEibrEJjFBvz1" /><figcaption>What people say vs What actually happened</figcaption></figure><p>What people say vs What actually happend</p><p>And for the first time, we can observe it directly.</p><p>No translation layer. No manual updates. No “keeping Jira in sync.”</p><h3>Jira Was Built for a Different Era</h3><p>Jira made sense when:</p><ul><li>Work had to be coordinated manually</li><li>Managers needed visibility into distributed teams</li><li>Code was harder to analyze at scale</li></ul><p>So we created a system where engineers:</p><ol><li>Do the work</li><li>Then document the work</li><li>Then explain the work</li></ol><p>Three layers of effort just to maintain visibility.</p><p>That model is breaking.</p><h3>The Cracks Are Already Showing</h3><p>If you’re building with AI — not just talking about it — you’ve seen it:</p><ul><li>Tickets that don’t reflect what actually shipped</li><li>Work happening outside the sprint</li><li>Sprints are planned directly in the repo using Claude Code/Codex with Markdown (.md) files</li><li>Engineers updating Jira after the fact or not at all</li><li>Velocity becoming a vanity metric</li></ul><p>And now add AI into the mix:</p><ul><li>AI writes code</li><li>AI reviews code</li><li>AI accelerates delivery</li><li>AI plans and refines sprints directly in the repo</li></ul><p>But Jira still expects a human to manually explain everything.</p><figure><img alt="Side-by-side view of a Jira board showing tickets marked Done versus a git log showing the reality: work-in-progress commits, untracked features, unplanned hotfixes, and AI-driven refactors with no corresponding tickets Caption: Jira says “Done” — Git says otherwise" src="https://cdn-images-1.medium.com/max/1024/0*TJ34VMNl8GWQ-WOb" /><figcaption>Jira says “Done” — Git says otherwise</figcaption></figure><p>Jira says “Done” — Git says otherwise</p><p>That gap is growing fast.</p><h3>What Replaces It?</h3><p>The next generation of systems won’t ask:</p><blockquote><em>“What ticket is this tied to?”</em></blockquote><p>They’ll answer:</p><ul><li>What actually shipped?</li><li>Who contributed?</li><li>What did it cost?</li><li>Which initiatives moved forward?</li><li>Where are the risks?</li></ul><p>Automatically.</p><p>Because the data already exists.</p><p>It’s just never been connected.</p><h3>The Rise of Execution Intelligence</h3><p>What’s emerging is a new category:</p><p>Execution Intelligence</p><p>A system that connects:</p><ul><li>Code → what changed</li><li>Strategy → why it changed</li><li>Knowledge → decisions behind it</li><li>Finance → what it cost</li></ul><p>And allows AI to reason across all of it.</p><figure><img alt="our-quadrant diagram showing Code (what changed), Strategy (why it changed), Knowledge (decisions behind it), and Finance (what it cost) connected through a central AI reasoning engine" src="https://cdn-images-1.medium.com/max/1024/0*WAUidg4hGOfZhXay" /><figcaption>Example meridianpay-knowledge</figcaption></figure><p>A system that connects Code, Strategy, Knowledge and Finance</p><p>Not dashboards. Not exports. Not manually curated metrics.</p><p>But answers backed by evidence.</p><h3>How Execution Intelligence Actually Works</h3><p>At this point, the obvious question becomes:</p><blockquote>If not Jira… then how does work actually get planned and executed?</blockquote><p>In AI-first teams, the model is already shifting.</p><ul><li>Meetings are captured and turned into structured knowledge</li><li>Decisions and intent are extracted automatically</li><li>That knowledge is pushed directly into a central repository</li><li>Sprints are defined in Markdown (.md) files alongside the work</li><li>Claude Code / Codex operate directly on that context</li></ul><p>In teams I work with, I set this up as a separate repository.</p><p>Not as “docs” or a “playbook” — but as the actual product execution layer.</p><p>Naming usually follows company-based patterns — company-context, company-knowledge, company-execution, or company-system — because this repo becomes the execution layer itself</p><figure><img alt="VS Code editor showing a meridianpay-knowledge repository with folders for domain, engineering, product, security, sources, and strategy — with strategy expanded to show initiatives and sprints nested underneath, and a sprint-25.md file open showing a sprint definition linked to the payment rails initiative" src="https://cdn-images-1.medium.com/max/1024/0*jjipMbDmzP4gEU8N" /></figure><p>Example merdianpay-knowledge</p><p>It’s no longer just where code lives.</p><p>It’s where the product is defined, built, and evolved.</p><p>Everything flows through it:</p><ul><li>initiatives — strategy</li><li>sprint definitions — strategy</li><li>features — product (arch. per feature and planning + executing features)</li><li>decisions from meetings — sources</li><li>architecture direction -engineering + per feature slic</li></ul><p>Now the repo isn’t just a codebase.</p><p>It becomes:</p><ul><li>the plan</li><li>the sprint</li><li>the execution layer</li></ul><p>All in one place.</p><h3>Where InteliG Comes In</h3><p>This is where <a href="https://intelig.ai/">InteliG</a> changes the game.</p><p>Because once planning and execution live in the same system, you can finally reason on top of it.</p><p><a href="https://intelig.ai/">InteliG</a> connects:</p><ul><li>meetings → structured knowledge</li><li>knowledge → initiatives</li><li>initiatives → commits and PRs</li><li>sprints → actual execution</li></ul><p>Now a sprint isn’t just what was planned.</p><p>It becomes a fully connected system of truth.</p><h3>From Sprint → What Actually Happened</h3><p>Because <a href="https://intelig.ai/">InteliG</a> sits on top of this execution layer, it can answer what no tool could before:</p><ul><li>What actually shipped this sprint?</li><li>Which initiatives moved forward?</li><li>Who drove the work?</li><li>What changed in the system?</li><li>What did it cost?</li></ul><p>Not based on tickets.</p><p>But based on:</p><ul><li>commits</li><li>pull requests</li><li>deployments</li><li>and their relationship to the sprint and initiatives</li></ul><p><a href="https://intelig.ai/">InteliG</a> doesn’t just track work.</p><p>It explains:</p><blockquote><em>what was planned, what actually happened, and what it means.</em></blockquote><figure><img alt="Sprint 25 Payment Rails v2 showing 47 commits, 12 PRs merged, 5 contributors, and 2 initiatives moved, with automatically generated answers to what shipped, which initiatives moved forward, and what it cost" src="https://cdn-images-1.medium.com/max/1024/0*wExSVSojwpBxYVse" /><figcaption>From sprint to automatic answers — based on real execution dataWha</figcaption></figure><p>From sprint to automatic answers — based on real execution</p><h3>This Is Why I Built InteliG</h3><p>I didn’t start with the idea of replacing Jira. If you’re a CTO or VP Engineering running an AI first org check out <a href="https://intelig.ai/">intelig</a>.</p><p>I started with the realization that:</p><blockquote><em>Jira was never telling the truth.</em></blockquote><p>It was telling a version of reality — filtered through tickets, updates, and human interpretation.</p><p>Meanwhile, the real signal was sitting in:</p><ul><li>the code</li><li>the commits</li><li>the decisions</li><li>the actual execution</li></ul><p>So I built <a href="https://intelig.ai/">InteliG</a> to operate on that layer instead.</p><p>No tickets. No manual tracking. No “keeping things in sync.”</p><p>Just a system that understands what actually happened.</p><p>When planning, execution, and intelligence all live in the same system… there’s nothing left for Jira to do.</p><p>I didn’t build it to kill Jira.</p><p>But it does.</p><h3>Jira Doesn’t Disappear — It Becomes Irrelevant</h3><p>Jira won’t vanish overnight — but for AI-first orgs, it already has.</p><p>Its role becomes:</p><ul><li>a coordination tool</li><li>a UI for process</li><li>a legacy layer for planning</li></ul><p>Not the source of truth.</p><p>Because the source of truth is now observable directly.</p><h3>The Bottom Line</h3><p>We’re moving from:</p><p>Planned Work → Tracked Work → Reported Work</p><p>To:</p><p>Actual Work → Observed → Understood</p><p>That shift is massive.</p><p>And it changes how engineering organizations are run.</p><p>The teams that adopt this early will:</p><ul><li>move faster</li><li>operate with clarity</li><li>make better decisions</li></ul><p>The ones that don’t will keep managing abstractions.</p><h3>Final Thought</h3><p>AI doesn’t need tickets.</p><p>It needs truth.</p><p>And the companies that build around that idea will define the next decade of software.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=765f1188c31d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Jira Won’t Survive the AI Era —]]></title>
            <link>https://medium.com/@levi_garner/jira-wont-survive-the-ai-era-fc6d8922d2d8?source=rss-53c9a3988c5e------2</link>
            <guid isPermaLink="false">https://medium.com/p/fc6d8922d2d8</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[developer-productivity]]></category>
            <category><![CDATA[agile]]></category>
            <category><![CDATA[cto]]></category>
            <dc:creator><![CDATA[Levi Garner]]></dc:creator>
            <pubDate>Wed, 18 Mar 2026 10:32:23 GMT</pubDate>
            <atom:updated>2026-03-18T10:32:23.938Z</atom:updated>
            <content:encoded><![CDATA[<h3>Because it’s the next COBOL — slow, painful, and kept alive only by habit until AI finally kills it.</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*voepYtGOjyzkv_su5kd6Cw.png" /><figcaption>Jira retirement party. Long overdue.</figcaption></figure><p>Let me be blunt: <strong>Jira is not built for the future of engineering.</strong><br>In the AI era, its entire model starts to fall apart.</p><p>AI doesn’t need a ticket to know what to do.<br>AI doesn’t need status updates.<br>AI doesn’t need sprint boards or grooming sessions.</p><p>AI understands <strong>code</strong>, <strong>diffs</strong>, <strong>patterns</strong>, <strong>errors</strong>, <strong>context</strong>, <strong>workflows</strong>, and <strong>intent</strong> — everything Jira was <em>never</em> designed for.</p><p>The more AI takes over execution, the more obvious this becomes:<br><strong>Jira’s workflow is friction for humans, noise for AI, and overhead for everyone.</strong></p><p>We’re entering a world where:</p><ul><li>Backlogs generate themselves</li><li>Bugs triage themselves</li><li>Tasks route themselves</li><li>Code changes explain themselves</li><li>Agents fix issues without human tickets</li><li>Work is tracked at the repo level, not the admin level</li></ul><p>And yet we’re expected to believe Jira survives this shift?</p><p>Jira is a relic from a time when engineering needed heavy coordination because humans were doing everything manually.<br>That world is gone.</p><p>AI collapses the distance between <em>idea → change</em>.<br>Jira extends it.</p><p>AI removes admin work.<br>Jira requires it.</p><p>AI lives at the code layer.<br>Jira lives in a UI from 20 years ago.</p><p>This isn’t about whether Jira is “good” or “bad.”<br>It’s about the fact that <strong>the assumptions Jira is built on no longer match how engineering actually works in the AI era.</strong></p><p><strong>So when does Jira actually die?</strong></p><p>Short answer:<br>3–4 years for modern teams.<br>6–8 years for legacy enterprises to finally admit it.</p><p><strong>Longer answer below.</strong></p><p><strong>Phase 1 (2024–2025): The cracks become impossible to ignore</strong><br>AI-first teams quietly stop relying on Jira for actual execution.<br>It stays open in a tab, but the real work moves to AI agents, repo-native workflows, and automated planning from code.</p><p>Jira becomes process theater.</p><p><strong>Phase 2 (2025–2027): Jira becomes optional</strong><br>Teams realize:</p><p>AI generates tasks from conversations.<br>AI predicts timelines without points.<br>AI updates statuses automatically.<br>AI triages bugs and assigns work.<br>AI replaces sprint planning entirely.</p><p>Jira turns into the new SharePoint — still technically there, but nobody wants to use it.</p><p><strong>Phase 3 (2027–2032): Structural collapse</strong><br>Organizations migrate to:</p><p>Git-native planning.<br>AI-native workflow engines.<br>Autonomous execution loops.<br>Repo-level governance.<br>Agent-to-agent coordination.</p><p>Executives stop asking for “ticket updates” because AI already reports real progress directly from code, not admin fields.</p><p>Jira survives only in enterprises where compliance matters more than speed — the same places COBOL still lives.</p><p><strong>Why this collapse is guaranteed</strong><br>Jira is built on three assumptions:</p><p>Humans create the work.<br>Humans coordinate the work.<br>Humans report the work.</p><p>AI destroys all three.</p><p>When agents plan, write, test, fix, deploy, and observe the system, Jira becomes what it really is:</p><p>An admin dashboard for a world that no longer exists.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fc6d8922d2d8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Feature-Driven Architecture Lives Inside DDD]]></title>
            <link>https://medium.com/@levi_garner/feature-driven-architecture-lives-inside-ddd-fcd0675412db?source=rss-53c9a3988c5e------2</link>
            <guid isPermaLink="false">https://medium.com/p/fcd0675412db</guid>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[domain-driven-design]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[design-systems]]></category>
            <dc:creator><![CDATA[Levi Garner]]></dc:creator>
            <pubDate>Tue, 17 Mar 2026 03:31:26 GMT</pubDate>
            <atom:updated>2026-03-17T03:31:26.031Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*S_Z7H_lG7kuObMJ7371vgw.png" /><figcaption>Same domain. Four architectures. Feature-Driven lives inside DDD.</figcaption></figure><p><em>In the age of AI agents and enterprise-scale systems, architecture matters more than ever not just for humans, but for machines that need to reason about your code.</em></p><p>One of the most common architecture misunderstandings I see is the idea that Feature-Driven architecture replaces Domain-Driven Design (DDD).</p><p>It doesn’t.</p><p>Feature-Driven architecture lives inside DDD.</p><p>The bounded context defines the boundary of a system. The features represent the workflows inside that boundary.</p><p>Here’s the same billing / subscription domain sliced four different ways — one wrong, three correct depending on the complexity of the domain.</p><h3>The Wrong Way: What Most People Call “DDD”</h3><p>Layered architecture with domain folders. God classes. No real boundaries.</p><p>AI agents get lost instantly.</p><pre>src/<br>├── controllers/<br>│   ├── CustomerController<br>│   ├── SubscriptionController<br>│   └── PaymentController<br>├── services/<br>│   ├── CustomerService              ← 2000 LOC god class<br>│   └── SubscriptionService          ← 3000 LOC god class<br>├── repositories/<br>│   ├── CustomerRepository<br>│   └── SubscriptionRepository<br>├── domain/                          ← sounds like DDD, but isn&#39;t<br>│   ├── Customer                     ← actually just entities<br>│   └── Subscription<br>├── models/<br>│   ├── CustomerDto<br>│   └── SubscriptionDto<br>└── utils/                           ← the junk drawer</pre><h3>What’s wrong here</h3><ul><li>Technical layers are the top-level organization</li><li>No bounded context boundaries</li><li>Services become god classes mixing commands and queries</li><li>Models are anemic — just getters and setters</li><li>Everything touches everything</li><li>“Service” classes violate Single Responsibility</li><li>The “domain” folder usually contains database entities, not real domain models</li></ul><p>Humans struggle to navigate it.</p><p>AI agents struggle even more.</p><h3>Pattern A: DDD + CQRS (Flat)</h3><p>A bounded context sits at the top.</p><p>Commands and queries are separated within the application layer.</p><p>This works well for small contexts with a handful of operations where everything still fits in your head.</p><pre>billing/<br>├── api/<br>│   ├── controller/<br>│   │   └── BillingController<br>│   └── dto/<br>│       ├── command/<br>│       │   ├── ChangePlanDto<br>│       │   └── CreateCheckoutDto<br>│       └── query/<br>│           ├── BillingOverviewDto<br>│           └── SubscriptionDto<br>├── application/<br>│   ├── command/<br>│   │   ├── CreateSubscriptionCommand<br>│   │   ├── ChangePlanCommand<br>│   │   ├── CancelSubscriptionCommand<br>│   │   └── CreateCheckoutSessionCommand<br>│   ├── query/<br>│   │   ├── GetBillingOverviewQuery<br>│   │   ├── GetSubscriptionQuery<br>│   │   └── GetInvoicesQuery<br>│   └── handler/<br>│       ├── command/<br>│       └── query/<br>├── domain/<br>│   ├── enums/<br>│   │   ├── PlanType<br>│   │   └── SubscriptionStatus<br>│   └── exception/<br>│       └── BillingException<br>└── infrastructure/<br>    ├── entity/<br>    └── repository/</pre><h3>Why it works</h3><ul><li>Clear bounded context boundary</li><li>Commands and queries are separated</li><li>Domain logic is isolated from infrastructure</li><li>Responsibilities are well defined</li></ul><h3>When it starts breaking down</h3><p>Once you have 10+ commands, the command/ folder becomes a wall of files.</p><p>You lose the signal of what the context actually does.</p><p>Developers have to open files just to understand the use cases.</p><h3>Pattern B: Feature-Driven + CQRS</h3><p>The same bounded context remains, but features become the top-level organization.</p><p>Each feature becomes a vertical slice that owns its API and application logic.</p><pre>billing/<br>├── feature/<br>│   ├── create-subscription/<br>│   │   ├── api/<br>│   │   └── application/<br>│   │       └── command/<br>│   │           ├── CreateSubscriptionCommand<br>│   │           └── CreateSubscriptionHandler<br>│   ├── change-plan/<br>│   │   ├── api/<br>│   │   └── application/<br>│   │       └── command/<br>│   │           ├── ChangePlanCommand<br>│   │           └── ChangePlanHandler<br>│   ├── cancel-subscription/<br>│   ├── checkout/<br>│   └── get-billing-overview/<br>│       ├── api/<br>│       └── application/<br>│           └── query/<br>├── domain/<br>│   ├── enums/<br>│   │   ├── PlanType<br>│   │   └── SubscriptionStatus<br>│   └── exception/<br>│       └── BillingException<br>└── infrastructure/</pre><h3>Why this works</h3><ul><li>Each feature is a vertical slice</li><li>Commands and queries remain separate</li><li>Features are isolated from each other</li><li>The architecture communicates intent</li></ul><p>A developer — or an AI agent — can look at:</p><pre>feature/change-plan/</pre><p>…and immediately understand the scope.</p><h3>Pattern C: Core Domain + Feature-Driven + Event Sourcing</h3><p>When the domain becomes more complex — aggregates, invariants, domain events — the architecture shifts again.</p><p>The core domain holds the shared business truth.</p><p>Features contain the use cases that operate on that domain.</p><pre>billing/<br>├── core/<br>│   ├── domain/<br>│   │   ├── aggregate/<br>│   │   │   └── Subscription<br>│   │   ├── model/<br>│   │   │   ├── SubscriptionPlan<br>│   │   │   └── PaymentMethod<br>│   │   ├── event/<br>│   │   │   ├── SubscriptionCreatedEvent<br>│   │   │   ├── PlanChangedEvent<br>│   │   │   └── PaymentFailedEvent<br>│   │   ├── port/<br>│   │   └── repository/<br>│   └── infrastructure/<br>│       ├── entity/<br>│       ├── mapper/<br>│       └── repository/<br>├── feature/<br>│   ├── create-subscription/<br>│   │   └── application/<br>│   │       └── command/<br>│   ├── change-plan/<br>│   │   └── application/<br>│   │       ├── command/<br>│   │       └── query/<br>│   ├── cancel-subscription/<br>│   └── get-billing-overview/</pre><h3>Why this works</h3><ul><li>The aggregate root enforces invariants</li><li>Domain events communicate across features</li><li>Infrastructure stays outside the domain</li><li>Features focus on use cases</li></ul><p>The architecture becomes very clear:</p><p>Core = domain truth Features = actions performed on that domain</p><h3>The Progression</h3><p>Architecture evolves as domains grow.</p><p>Pattern A — Flat CQRS Use when contexts are small with only a handful of operations. Domain complexity: Low</p><p>Pattern B — Feature-Driven Use when a context has many workflows and needs clear grouping by use case. Domain complexity: Medium</p><p>Pattern C — Core Domain + Features Use when the domain contains real business invariants, aggregates, and domain events. Domain complexity: High</p><p>The “wrong way” has no bounded context, no domain isolation, and no separation of commands and queries.</p><p>The three patterns above represent a progression as domain complexity increases.</p><h3>The Real Takeaway</h3><p>Feature-Driven architecture does not replace DDD.</p><p>It organizes workflows inside a bounded context.</p><p>The people who say they don’t like DDD are usually reacting to layered architectures that were labeled “DDD.”</p><p>Real Domain-Driven Design starts with clear domain boundaries.</p><p>Everything else lives inside them.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fcd0675412db" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>