<?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 Dr. Simon Bogutzky on Medium]]></title>
        <description><![CDATA[Stories by Dr. Simon Bogutzky on Medium]]></description>
        <link>https://medium.com/@simonbogutzky?source=rss-e85e115a0166------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*fhOZBOc3_QZqHbGYJ6kGdg.jpeg</url>
            <title>Stories by Dr. Simon Bogutzky on Medium</title>
            <link>https://medium.com/@simonbogutzky?source=rss-e85e115a0166------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 21:20:05 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@simonbogutzky/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[Does BMAD Really Burn That Many Tokens?]]></title>
            <link>https://medium.com/@simonbogutzky/does-bmad-really-burn-that-many-tokens-866320da3db4?source=rss-e85e115a0166------2</link>
            <guid isPermaLink="false">https://medium.com/p/866320da3db4</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[productivity]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Dr. Simon Bogutzky]]></dc:creator>
            <pubDate>Sun, 14 Jun 2026 14:48:07 GMT</pubDate>
            <atom:updated>2026-09-23T09:49:42.060Z</atom:updated>
            <content:encoded><![CDATA[<h3>I built the same feature three times — with three agent-based workflows, five runs each — and put a stubborn assumption to the test.</h3><p>I hear it from colleagues all the time: “BMAD burns way more tokens.” Whenever agent-based development comes up, BMAD gets cast as the heavy machinery — lots of workflows, lots of documents, lots of context, and therefore expensive. The lean alternatives, people say, get you to the same result for a fraction of the cost.</p><p>It’s a reasonable assumption. But reasonable isn’t the same as measured. So I measured it.</p><p>I built the same feature three times — once with BMAD, once with Claude Code in plain Normal Mode, and once with GSD:quick — and tracked what each one actually cost. (A token, by the way, is just the unit of text an AI model processes and gets billed for.)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8q5unz8751Gx9HTM_U4ahg.png" /><figcaption>Three agentic workflows, one Flutter feature, five runs each. Measured cost in USD, Sonnet 4.6.</figcaption></figure><h3>What BMAD Actually Is</h3><p>BMAD is a document-driven, persona-based development process. Instead of one model building one feature in a single go, it splits the work into specialized steps — analysis, product planning, architecture, UX/UI, implementation, and review — and runs each step as its own persona, an agent with a defined role. Between the steps, it produces real artifacts: a product requirements document, an architecture document, a UX/UI spec, and self-contained story files that a developer agent implements and a reviewer agent checks.</p><p>This is exactly where the “token hog” reputation comes from. Each persona loads its own profile and the documents it needs into the context. What a single session would handle in one pass, BMAD spreads across many sub-sessions, each carrying its own context. On paper, that looks like a huge amount of extra work.</p><p>The counterargument is that the extra work buys something. Traceable interim results, a clean split between planning and implementation, documents you can actually review — and a story with reviewed acceptance criteria that gives the agent a concrete, checkable target instead of a loose prompt. In regulated contexts like public administration, that isn’t overhead, it’s part of what you have to deliver. The only real question is: how much does it cost?</p><h3>How I Set Up and Ran Each Method</h3><p>The feature was an overview screen from a Flutter project: a header, a hero card with a call to action, and a 2×2 grid of service tiles. Deliberately ordinary.</p><p>To keep the comparison fair, everything except the method stayed the same:</p><ul><li><strong>Same input:</strong> one story file (generated once with BMAD) plus the Figma designs, pulled through the local Figma Dev Mode MCP server.</li><li><strong>Same model:</strong> Sonnet 4.6, medium effort.</li><li><strong>Same gate:</strong> a frozen, checked-in unit test suite that had to stay green. No method was allowed to touch the tests.</li><li><strong>Same tool:</strong> the Claude Code CLI, with a fresh session for every run.</li><li><strong>Five runs per method</strong>, plus a visual check against a reference screen.</li></ul><p>Each method also needs some one-time setup, and I kept that out of the measured token budget — otherwise I’d be charging each method for its starting line instead of the race:</p><ul><li><strong>BMAD</strong> ran through its dev-story workflow. I pointed it at the story (/bmad-dev-story 2.1), it pulled the Figma context, and implemented against the story. BMAD also has a separate review workflow, but I left it out on purpose — running it would be a second workflow, the other two methods don’t have, and I wanted all three doing comparable work.</li><li><strong>Normal Mode</strong> first got a CLAUDE.md from /init. Then I handed it the same story file and asked it to implement the feature.</li><li><strong>GSD</strong> ran via /gsd:quick on the story. It needed one extra step here — mapping the codebase and creating its project context — but only because the project was already initialized for BMAD. That’s an artifact of the order I set things up in, not a property of GSD: had I started with GSD and added BMAD second, the extra setup would have landed on BMAD instead.</li></ul><p>The instruction after each command was identical for all three — same story, same Figma reference, same “tests must stay green” rule. The only thing that changed was the method.</p><h3>Where the Reliability Actually Comes From</h3><p>The token numbers don’t capture the thing that actually makes the AI’s work dependable: the acceptance criteria.</p><p>In this study, every method ran against the same story — a BMAD-generated story with explicit acceptance criteria that I reviewed and revised by hand. That was deliberate: a fair comparison needs the same input for all three. So all three, Normal Mode included, had a human-approved definition of “done” to build toward. The gate that enforced it was a frozen test suite, generated up front by a separate Opus 4.8 run — done outside the five runs of each method, so it never counted against any method’s budget — which turned those acceptance criteria into checks every method had to pass.</p><p>That is what made the output reliable across the board. The agent wasn’t guessing at intent; it was making specific, checkable things true.</p><p>The real question is where that story comes from. Plain Normal Mode doesn’t produce it — it consumes one. BMAD and GSD do produce it: they draft the criteria, structure the story, and shard it for implementation. Here I generated the story once with BMAD and reused it everywhere, which is why that spec work sits outside the numbers above. If you don’t already have a reviewed spec with clear acceptance criteria, a spec-driven workflow is how you get one — and that, far more than the token count, is the reason to use it. And with TDD, the Dev Agent turns those acceptance criteria into tests before it writes any production code — so “looks right” stops being the bar it grades itself on.</p><h3>Tokens Are Not Costs</h3><p>The obvious indicator is the token count — and that’s exactly what feeds the myth. But the count doesn’t tell you the bill.</p><p>When I broke the numbers down, 96 to 97 percent of the tokens in every run and for every method were cache reads — reused context that costs about a tenth of a normal input token. A BMAD run with a good ten million tokens came out to $4.77, because almost all of it was cache reads. That’s roughly 47 cents per million tokens.</p><p>So the real cost driver isn’t what a method generates. The actual output was tens of thousands of tokens, a tiny slice. It’s the large context — mostly the Figma metadata — that gets carried along and re-read at every step. And that mechanism hits all three methods the same way. If you judge BMAD by its raw token count, you’re not measuring waste. You’re measuring a cache effect that shows up everywhere.</p><h3>The Results</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/754/1*cmRFEdjCK7xJmOF8w2HE4g.png" /><figcaption>Average results across five runs per method. Cost measured directly via opcode; design scored against an Opus 4.8 reference screen using a fixed rubric. Model: Sonnet 4.6, medium effort.</figcaption></figure><p>And that’s where the myth falls apart.</p><p><strong>BMAD isn’t the biggest spender.</strong> It sits in the middle — and it actually uses fewer tokens (8.64M vs. 9.17M) and costs less ($4.12 vs. $4.46) than GSD, which fans out into the most sub-sessions, up to 121 per run, and carries the highest cache-write load as a result. That’s not a knock on GSD — it’s just where the numbers landed for this feature.</p><p><strong>BMAD scores best on design.</strong> It comes out on top in the visual check (3.8 out of 5), though only just — the three are close, and the variation came from the odd asset glitch, not from the method.</p><p>And here’s the honest part: against plain Normal Mode, BMAD does use more — about 45 percent more tokens. But because almost all of it is cache reads, that’s only around 79 cents more per feature. Normal Mode stays the cheapest, and usually the fastest, option if all you want is the code.</p><h3>So Which One Should You Use?</h3><p>All three are cheap, so cost shouldn’t drive the choice. Reliability and what you need to hand off should be.</p><p>If you want a checkable definition of done — acceptance criteria, a human-approved, tests the agent has to satisfy — go spec-driven: GSD or BMAD. Both produce that spec for you, where plain Normal Mode expects you to bring one. BMAD adds the full document trail on top — PRD, architecture, UX spec, and a separate review step — which is what you want for bigger features, cross-team coordination, or regulated work where the documentation is part of the deliverable. GSD gives you the spec-driven reliability with less of that scaffolding.</p><p>Plain Normal Mode is the right call when the work is small, well-defined, and low-risk, and you want it now — no criteria to write, no artifacts to keep.</p><p>A quick checklist:</p><ul><li>Tiny, well-defined, low-risk, and you want it now? → <strong>Normal Mode</strong>.</li><li>Want reviewed acceptance criteria and test-backed reliability? → <strong>GSD or BMAD</strong>.</li><li>Need documentation, compliance, sign-offs, or cross-team handoffs as part of the deliverable? → <strong>BMAD</strong>.</li></ul><h3>What the Measurement Actually Shows</h3><p>The gap between the cheapest and the most expensive method is about a dollar per feature, with cache reads making up roughly 96 percent of every run. The differences are small, and none of them make BMAD the expensive one. These numbers hold for small to medium features like this one. For much larger projects the absolute costs grow, but the cache-heavy pattern should stay the same; truly large projects, with far more documents and session steps, would be worth a separate look.</p><p>BMAD’s extra consumption is a trade, not waste: a few cents more than the leanest option, in exchange for structured documents, planning steps, and a real review. In a context where traceability is required, that “overhead” is part of the deliverable.</p><p>BMAD is not the cheapest option. But it’s also not the token hog people think it is. That reputation comes from staring at raw token counts instead of costs — and it doesn’t survive the first proper measurement.</p><p>Have you measured your own agent workflows, or are you still going on gut feeling? I’d be curious what you find.</p><h3>Sources</h3><ul><li>BMAD-METHOD — <a href="https://github.com/bmad-code-org/bmad-method">https://github.com/bmad-code-org/bmad-method</a></li><li>Get Shit Done (GSD) — <a href="https://github.com/open-gsd/gsd-core">https://github.com/open-gsd/gsd-core</a></li><li>Claude Code (Anthropic) — <a href="https://docs.claude.com/en/docs/claude-code">https://docs.claude.com/en/docs/claude-code</a></li><li>ccusage, token and cost analysis for Claude Code — <a href="https://github.com/ryoppippi/ccusage">https://github.com/ryoppippi/ccusage</a></li><li>Figma Dev Mode MCP server — <a href="https://developers.figma.com/docs/figma-mcp-server/">https://developers.figma.com/docs/figma-mcp-server/</a></li><li>Anthropic prompt caching (cache-read pricing) — <a href="https://docs.claude.com/en/docs/build-with-claude/prompt-caching">https://docs.claude.com/en/docs/build-with-claude/prompt-caching</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=866320da3db4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Same Feature, Three Ways: What 2.3M vs. 7.4M Tokens Teaches Us About AI Development Workflows]]></title>
            <link>https://medium.com/@simonbogutzky/the-same-feature-three-ways-what-35-9k-b2c3b7a0a912?source=rss-e85e115a0166------2</link>
            <guid isPermaLink="false">https://medium.com/p/b2c3b7a0a912</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[claude]]></category>
            <category><![CDATA[ios-development]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[productivity]]></category>
            <dc:creator><![CDATA[Dr. Simon Bogutzky]]></dc:creator>
            <pubDate>Tue, 10 Mar 2026 12:57:07 GMT</pubDate>
            <atom:updated>2026-03-16T08:22:18.924Z</atom:updated>
            <content:encoded><![CDATA[<h3>The Feature: A Transfer Function for a Budget App</h3><p>The task: add a transfer function to an existing private iOS SwiftUI budget app. Transferring funds between accounts creates paired entries (e.g., minus 100 and plus 100). This should be toggleable at the category level — off by default, enabled when the user marks a category as “Transfer.”</p><p>The aim was to add this feature to a working app, reflecting the incremental changes typical in a real codebase.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KlZnrAZhHHHUAMmQox-vDg.png" /></figure><h3>Three Workflows, One Feature</h3><h3>Approach 1: Claude Code Plan Mode</h3><p><a href="https://claudelog.com/mechanics/plan-mode/">Plan Mode</a> is a read-only mode built into Claude Code. Activated by pressing Shift+Tab twice or launching with — permission-mode plan, it restricts Claude to analysis and planning — reading files, identifying dependencies, generating a structured implementation plan — before writing any code. Planning and implementation run as a single continuous session: Claude presents the plan, you review it, and execution proceeds within the same context.</p><p>The appeal is control. Plan Mode separates reasoning from execution, surfacing assumptions early and preventing premature changes to files you didn’t intend to modify. For a self-contained feature like this one, the overhead is low.</p><p>Total tokens: 2,254,520 — Cost: ~$13.53</p><h3>Approach 2: BMAD Quick Flow (Quick Spec + Quick Dev)</h3><p>BMAD’s <a href="https://docs.bmad-method.org/explanation/quick-flow/">Quick Flow</a> is designed for features with a clear scope — roughly 1 to 15 stories. I ran it on the same private iOS SwiftUI app specifically to test how Quick Spec and Quick Dev handle an existing codebase. It runs in two sequential sessions:</p><ul><li>Quick Spec scans the codebase, asks clarifying questions, and produces a complete tech spec including implementation tasks, acceptance criteria in Given/When/Then format, a testing strategy, and dependency mapping.</li><li>Quick Dev takes that spec and executes it: implements each task in order, writes tests, and verifies acceptance criteria before marking the story complete.</li></ul><p>The structured output is Quick Flow’s main advantage. The spec is a reviewable artifact. The acceptance criteria are explicit. The dev agent validates against them before closing out.</p><p>Total tokens: 4,345,760 (Quick Spec) + 3,058,360 (Quick Dev) = 7,404,120 — Cost: ~$26.07 + $18.35 = $44.42</p><h3>Approach 3: Skill-Based BMAD (Quick Spec Skill + Quick Dev Skill)</h3><p>For the third run, I used the <a href="https://support.claude.com/en/articles/12512198-how-to-create-custom-skills">Skill Creator</a> — a meta-skill from Anthropic’s official skills repository — to generate dedicated Claude Skills for the BMAD Quick Spec and Quick Dev workflows. The Skill Creator analyzes your intent, captures the workflow structure, and writes a SKILL.md file that defines when and how the skill activates. I then ran the same feature on the same private iOS SwiftUI app using those generated skills.</p><p>The resulting skills execute the same steps and draw on the same resources as the standard BMAD Quick Flow — but only load what is actually needed for each step. All workflow logic is contained within the skill itself — no BMAD installation required to run it. A BMAD installation is only optional if you want the correct agent persona and addressing from the BMAD configuration. This is what reduces context overhead per invocation.</p><p>Total tokens: 2,041,000 (Quick Spec Skill) + 2,744,360 (Quick Dev Skill) = 4,785,360 — Cost: ~$12.25 + $16.47 = $28.72</p><h3>The Numbers</h3><p>Costs estimated at Sonnet 4.6 pricing ($3.00/MTok input, $15.00/MTok output), assuming a 75/25 input/output split.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/750/1*Ey4YVHbjEEqQvePMwnqtlQ.png" /><figcaption>The Numbers</figcaption></figure><p>Three observations stand out.</p><p>Plan Mode is the most token-efficient by a wide margin. At 2,254,520 tokens and $13.53, it consumed less than a third of the standard BMAD Quick Flow. For a well-scoped feature in an existing codebase, the overhead of structured spec-driven workflows may not be worth it.</p><p>The Skill-based approach reduced BMAD’s total cost by 35%. Moving Quick Spec from 4,345,760 to 2,041,000 tokens — a 53% reduction — is significant. Quick Dev saw a smaller improvement, dropping from 3,058,360 to 2,744,360 tokens (10%). The Quick Spec phase benefits more from skill packaging because it is inherently context-heavy, requiring the loading of workflow definitions, agent instructions, and discovery scaffolding. A skill encapsulates that logic in a much smaller footprint.</p><p>The spec phase alone costs nearly as much as Plan Mode’s full implementation. The Quick Spec Skill consumed 2,041,000 tokens — and covered only planning, with no implementation and no tests. Plan Mode at 2,254,520 tokens delivered the full feature. To finish the skill-based implementation, the Quick Dev Skill added an additional 2,744,360 tokens. The real efficiency gap only becomes visible when comparing end-to-end: 2,254,520 versus 4,785,360 or 7,404,120.</p><h3>What the Skill Creator Changes</h3><p>The <a href="https://github.com/anthropics/skills/blob/main/skills/skill-creator/SKILL.md">Skill Creator</a> is itself a skill — one that creates other skills. You describe what workflow you want to capture, and it produces a SKILL.md stored in your .claude/skills/ directory.</p><p>The result is a focused prompt with a defined trigger. A generated Quick Dev skill, for example, activates automatically when you write phrases like “implement this”, “quick-dev”, “dev this spec”, or “build this feature” in your prompt. The SKILL.md defines both what the skill does and when Claude should apply it.</p><p>Critically, the skill runs the same steps as the BMAD Quick Dev workflow and can access the same resources — but only loads them when necessary. All workflow logic is embedded directly in the skill — no BMAD installation is needed to run it. A BMAD installation is only optional if you want the correct agent persona and addressing from the BMAD configuration. The token savings come from this self-contained loading, not from skipping steps.</p><p>For BMAD users, this opens a practical path: the same structured workflow, at lower context cost per run.</p><h3>Download the Skills</h3><p>Both skills are available for download and can be installed directly into Claude Code. Each .skill file is a self-contained archive — no BMAD installation required to run the workflows.</p><p><strong>Quick Spec Skill</strong> — 4 steps: understand → investigate → generate → review<br>Triggers on: “create a quick spec”, “spec this out”, “help me spec a feature”</p><p><a href="https://github.com/simonbogutzky/claude-bmad-skills/releases/download/1.0.0/quick-spec.skill">Download quick-spec.skill</a></p><p><strong>Quick Dev Skill</strong> — 6 steps: mode detection → context gathering → execute → self-check → adversarial review → resolve findings<br>Triggers on: “implement this”, “quick-dev”, “dev this spec”, “build this feature”</p><p><a href="https://github.com/simonbogutzky/claude-bmad-skills/releases/download/1.0.0/quick-dev.skill">Download quick-dev.skill</a></p><p>To install, place the extracted folder in your .claude/skills/ directory. Claude Code will pick it up automatically on the next session.</p><h3>When to Use Which Approach</h3><p>Based on this experiment, my current heuristic is:</p><ul><li>Plan Mode for self-contained, well-defined features in an existing codebase. Fast, cheap, and sufficient when the scope is clear.</li><li>BMAD Quick Flow when the feature touches multiple components, the acceptance criteria need to be formalized, or you want an artifact you can review and hand off. The token cost is real but so is the structured output.</li><li>Skill-Based BMAD as a middle path: you get structured spec output and explicit acceptance criteria at roughly 65% of the standard Quick Flow cost. Worth investing in if you run Quick Flow regularly. The upfront cost of building the skill pays off quickly.</li></ul><h3>A Note on Same-Prompt Comparisons</h3><p>All three runs started from the same initial prompt. This matters: the differences in token consumption are not explained by richer prompts or more context provided to one approach. The overhead is structural — how much each workflow consumes before producing its first output.</p><p>This kind of controlled comparison is something I plan to repeat as workflows evolve. Token consumption is not the only metric that matters — output quality, code correctness, and the reviewability of artifacts all factor in. But it is the one that shows up on your invoice and is measurable.</p><p>If you’ve compared BMAD’s Quick Flow with other workflows, share your findings in the comments.</p><p>Sources:</p><ul><li><a href="https://claudelog.com/mechanics/plan-mode/">Plan Mode in Claude Code — claudelog.com</a></li><li><a href="https://code.claude.com/docs/en/common-workflows">Common Workflows — Claude Code Docs</a></li><li><a href="https://docs.bmad-method.org/explanation/quick-flow/">Quick Flow — BMAD Method Docs</a></li><li><a href="https://support.claude.com/en/articles/12512198-how-to-create-custom-skills">How to Create Custom Skills — Claude Help Center</a></li><li><a href="https://github.com/anthropics/skills/blob/main/skills/skill-creator/SKILL.md">Skill Creator — anthropics/skills on GitHub</a></li><li><a href="https://code.claude.com/docs/en/skills">Extend Claude with Skills — Claude Code Docs</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b2c3b7a0a912" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Idea to Application, Part 2: The Real Cost of BMAD and Choosing the Right LLM]]></title>
            <link>https://medium.com/@simonbogutzky/from-idea-to-application-part-2-the-real-cost-of-bmad-and-choosing-the-right-llm-a1d419d3f46d?source=rss-e85e115a0166------2</link>
            <guid isPermaLink="false">https://medium.com/p/a1d419d3f46d</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[mobile-app-development]]></category>
            <category><![CDATA[agile-methodology]]></category>
            <category><![CDATA[ai-driven-development]]></category>
            <category><![CDATA[bmad-framework]]></category>
            <dc:creator><![CDATA[Dr. Simon Bogutzky]]></dc:creator>
            <pubDate>Thu, 19 Feb 2026 14:49:07 GMT</pubDate>
            <atom:updated>2026-02-19T14:49:07.374Z</atom:updated>
            <content:encoded><![CDATA[<p><em>This is the second part of my series on building a break app for screen workers using the BMAD method. If you haven’t read </em><a href="https://medium.com/@simonbogutzky/from-idea-to-application-my-development-of-a-break-app-for-screen-workers-using-bmad-5765d981283f"><em>Part 1</em></a>, I recommend starting there for context on the methodology and the first story implementation.</p><h3>The Subscription Problem</h3><p>In Part 1, I mentioned that a single Claude Pro subscription is insufficient for BMAD workflows. I experienced this firsthand: I frequently hit the usage limit and had to pause work for several hours at a time before I could continue. For a methodology this token-intensive, entry-level subscriptions simply don’t hold up.</p><p>Anthropic has started a massive ban wave, blocking accounts that run automated coding tools through a private flat-rate subscription. Behind the scenes, a hard economic reality is playing out. Anthropic calls it the “buffet problem”: users are pushing enormous amounts of tokens through third-party tools that would cost thousands of dollars via the official API. Anyone using a $20 subscription as a cheap pipeline is violating the terms of service and risks immediate account loss.</p><p>The natural alternatives are advanced developer subscriptions or pay-per-use. And with the latter, it’s time to do an honest cost calculation for the full project.</p><h3>The Economics of a Full iOS App</h3><p>To plan properly, I looked up current pricing on OpenRouter, a platform I’ve come to appreciate for its transparent model comparisons and weekly usage rankings across providers.</p><p>My break app consists of approximately 20 stories. Based on my BMAD workflow distributions, the full project will consume roughly 570 million tokens — 70 million for everything up to the first story, and approximately 25 million per story thereafter.</p><p>At that scale, the choice of model has a dramatic impact on cost:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/604/1*yY6vyG5p_hYgEr-V8Qt7Vw.png" /><figcaption><em>Actual cost depends on the input/output token ratio. Estimates are based on my BMAD workflow distributions.</em></figcaption></figure><p>Sonnet 4.5 incurs the highest costs — even though it is not Anthropic’s flagship model. The wide range within each model reflects the ratio of input to output tokens, which varies considerably between the analysis-heavy early phases and the implementation phases.</p><h3>You Don’t Need a Flagship Model for Coding</h3><p>OpenRouter publishes weekly rankings of the most-used models by category. In Week 7 of 2026, the top programming models by token volume were MiniMax M2.5 and Kimi K2.5 — both ahead of flagship offerings from Anthropic, OpenAI, and Google. This is a useful signal: the developer community, optimizing for both cost and quality, is not defaulting to the most expensive models.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/981/1*ADWxWvUtt2_wwPMb82-4Ow.png" /><figcaption>Week 7 of 2026, top programming models by token volume at OpenRouter</figcaption></figure><p>This matters specifically for BMAD, where token consumption compounds across every story. Finding a model that balances code quality, workflow compatibility, and cost is more important than chasing benchmark leaderboards.</p><h3>LLM Comparison: Implementing the Second Story</h3><p>To validate model choices beyond cost, I tested five models on the second-story implementation. My evaluation criteria were workflow support (does the model follow BMAD’s agent-based structure?), code quality, and whether the result was actually runnable without significant manual correction.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/604/1*l7YRmb4_Nysn6MX7U1N18g.png" /><figcaption>LLM Comparison: Implementing the Second Story of an iOS App</figcaption></figure><p>DeepSeek V3.2 failed to follow the BMAD workflow structure entirely — a hard blocker for this use case. Both DeepSeek and Gemini Flash 2.5 produced code that required significant manual correction before it would run.</p><p>Kimi K2.5 and MiniMax M2.5 are the most compelling alternatives to Sonnet: both understand BMAD’s agent structure, produce good-quality runnable code, and cost a fraction of the price. I have since switched to MiniMax M2.5 as my preferred model for implementation phases via OpenRouter.</p><blockquote>One important practical discovery: BMAD workflows in the implementation phase should not be started directly. Asking the dev agent to initiate them yields better results, as the agent then correctly applies its own customization context.</blockquote><blockquote>/bmad-agent-bmm-dev [cmd]<br>[CH] Chat with the Agent about anything<br>[DS] Dev Story: Write the next or specified stories, tests, and code.<br>[CR] Code Review: Initiate a comprehensive code review across multiple quality facets.</blockquote><h3>Takeaways: AI-Assisted Development vs. BMAD</h3><p>After completing multiple stories, I can now compare the two approaches with some data behind my observations:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/452/1*gNjArbWtdwjHZXodKuJJuQ.png" /><figcaption>AI-Assisted Development vs. BMAD</figcaption></figure><p><strong>BMAD trades control for velocity and consistency.</strong> Neither approach is token-efficient — but for different reasons. With traditional AI-assisted development, you repeat context manually across sessions. With BMAD, the structured prompts and sharded documents are inherently large.</p><p>What I genuinely valued about BMAD was the agent-guided process and the validation gates. For example, the dev agent reviews the implementation to confirm that the Given/When/Then acceptance criteria are met before marking a story as complete. That kind of structured accountability is difficult to replicate in a manual, chat-based workflow.</p><p>What I liked less at first: I no longer know large parts of my codebase as well as I used to. When I wrote the code myself with AI assistance, I naturally absorbed it. With BMAD, I review and guide rather than write. But the more I reflect on this, the less it feels like a real objection. Reports suggest that around 90% of the code in tools like Claude Code and OpenAI Codex is now written by AI. The industry is moving toward a model in which the developer’s job is to review and guide rather than hand-craft every line. Codebase familiarity as a metric may simply be less relevant than it was. However, what still matters are small tasks and rapid feedback loops through unit and integration tests. Since AI writes code faster than we do, we need to check the code it generates more frequently than before, when code was still written by humans.</p><p><strong>BMAD is particularly well-suited to client work where documentation and reproducibility matter.</strong> The generated artifacts — PRD, architecture document, UX spec, sprint status, story files — are a natural deliverable in a professional context.</p><h3>A Note on Pricing</h3><p>One assumption I bring to this work: subscription-based pricing for AI tools will likely rise or disappear. Companies like Anthropic and OpenAI need to become profitable, and flat-rate subscriptions at current prices are difficult to sustain at scale. Pay-per-use via platforms like OpenRouter, combined with deliberate model routing based on task type and cost, may become the standard workflow for serious AI-assisted development. The good news is that the model landscape is competitive enough that you don’t have to pay flagship prices to get good results.</p><p>I will continue reporting on the remaining stories and epics.</p><p>If you are experimenting with BMAD or other AI-assisted development frameworks, I’d like to hear about your experience in the comments.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a1d419d3f46d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Idea to Application: My Development of a Break App for Screen Workers Using BMAD]]></title>
            <link>https://medium.com/@simonbogutzky/from-idea-to-application-my-development-of-a-break-app-for-screen-workers-using-bmad-5765d981283f?source=rss-e85e115a0166------2</link>
            <guid isPermaLink="false">https://medium.com/p/5765d981283f</guid>
            <category><![CDATA[bmad-framework]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[agile-methodology]]></category>
            <category><![CDATA[mobile-app-development]]></category>
            <category><![CDATA[ai-driven-development]]></category>
            <dc:creator><![CDATA[Dr. Simon Bogutzky]]></dc:creator>
            <pubDate>Wed, 04 Feb 2026 18:54:27 GMT</pubDate>
            <atom:updated>2026-02-19T15:01:51.665Z</atom:updated>
            <content:encoded><![CDATA[<h3>Introduction</h3><p>To develop my new application, which facilitates breaks during intensive screen work and offers targeted exercises to alleviate neck and shoulder tension, I employed the BMAD method.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TLBC-SBLRHxXMK6giU9vZQ.jpeg" /><figcaption>Each agent is an expert in its domain, with structured prompts and validation steps.</figcaption></figure><p>BMAD, or ‘Breakthrough Method of Agile AI-Driven Development,’ is an AI-supported agile development framework comprising 21 specialized agents, more than 50 guided workflows, and scalable intelligence adaptable from minor bug fixes to enterprise-level systems. I selected BMAD for its ability to enable efficient, structured AI-driven project development. The method is organized into several phases, each with designated workflows:</p><ul><li><strong>Analysis:</strong> Brainstorming, research, product description (optional)</li><li><strong>Planning:</strong> Create requirements (PRD or tech spec)</li><li><strong>Solution finding:</strong> Design architecture (BMad Method/Enterprise only)</li><li><strong>Implementation:</strong> Build (Epic by epic, story by story)</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3CCwDkFKW1J1y-d-XyEaDQ.jpeg" /><figcaption>Each workflow is guided by questions from the agents</figcaption></figure><p>BMAD provides three distinct tracks tailored to a project’s scope. As my project was a greenfield initiative, I implemented the complete BMAD methodology.</p><ul><li><strong>Quick Flow: </strong>Bug fixes, simple features, clear scope (1–15 stories) → Tech-spec only</li><li><strong>BMad Method: </strong>Products, platforms, complex features (10–50+ stories) → PRD + Architecture + UX</li><li><strong>Enterprise: </strong>Compliance, multi-tenant systems (over 30 stories) → PRD + Architecture + Security + DevOps</li></ul><h3>Let’s Get Started</h3><h4>Installation</h4><p>At the outset of development, I organized the project by establishing a dedicated folder in the file system and initializing a local Git repository for version control. This foundational setup facilitated systematic organization of subsequent development activities and enabled effective tracking of code changes. I then navigated to the project directory in the terminal and executed the following npm Package Manager command:</p><pre>npx bmad-method install</pre><p>This started a guided configuration in which I selected BMAD Core as a module and Claude as the AI tool. The installation created the following folders in the project directory:</p><ul><li>_bmad/ — Agents, workflows, tasks, and configuration</li><li>_bmad-output/ — Folder was empty and served as a storage location for phase artifacts</li></ul><p>Subsequently, I launched an AI-integrated development environment (IDE) that provided access to all BMAD commands. I used Claude Code in the terminal, and the /bmad-help command provided assistance at any stage of the process.</p><p>I initiated each workflow in a new, empty chat to minimize costs. This approach reduced the likelihood that prior information would affect the current phase and helped control token consumption.</p><h3>Phase 1: Analysis (Optional)</h3><h4>Brainstorming — guided ideation</h4><p><em>(/bmad-brainstorming — 2.5 hrs — 626,100 tokens — $1.26)<br></em>In this workflow, I progressed through four steps, from initial setup to idea organization. The agent posed targeted questions, and by leveraging ideation methods (up to 62), I refined my concept. This process was especially beneficial for generating new ideas, though it is not required for projects with well-defined objectives. Notably, brainstorming is considered a core workflow, alongside extended discovery and party mode, rather than a formal component of the analysis phase.</p><blockquote><em>Alternatively, I had previously worked exclusively with Claude as a tool for ideation. In that case, both the inputs and the results were less structured.</em></blockquote><h4>Research — Market</h4><p><em>(/bmad-bmm-research — 1 hr — 6,713,900 tokens — $13.48)<br></em>In this workflow, the agent utilized the developed concept to conduct a comprehensive market analysis. The web-based research proved time-intensive due to the volume of information, resulting in slower progress and increased costs. It also became evident that automated analysis could not capture all pertinent details, particularly those specific to the market or context. Manual research revealed a distinct market gap that existing products do not address. This insight prompted a revision of the app’s positioning strategy and the integration of features tailored to this underserved segment. Consequently, supplementary manual research was essential to address gaps in the automated analysis and achieve a thorough understanding of the market.</p><blockquote><em>When using Claude exclusively for research, the results were less structured, which was also due to my unstructured input.</em></blockquote><h4>Research — Domain</h4><p><em>(/bmad-bmm-research — 0.75 hrs — 8,260,000 tokens — $16.58)<br></em>This research workflow was shorter than the market analysis and focused on scientific publications, which increased token consumption.</p><h4>Research — Technology</h4><p><em>(/bmad-bmm-research — skipped)</em></p><h4>Product Brief</h4><p><em>(/bmad-bmm-create-product-brief — 2 hrs — 7,690,000 tokens — $15.44)<br></em>The product brief workflow comprised several steps: I first articulated the core vision by defining the problem to be addressed, identifying target users, establishing success metrics, and delineating the project scope. During each session, agents could initiate further analyses through targeted questions. Extended discovery incorporated methods such as investor or persona reviews, whose feedback I could directly integrate. In party mode, the agent-based development team collaboratively discussed each step and submitted change requests, which I could choose to implement. While this collaborative approach fostered creativity and diverse perspectives, it occasionally resulted in overly broad discussions or diluted priorities. Overall, this dynamic was productive but required additional time and token resources. Although optional, the product brief significantly enhanced planning; without it, I would have needed to compensate for this effort during the planning phase.</p><blockquote><em>In contrast, when using Claude exclusively, I had created the product brief in a single prompt, since brainstorming and research were still available in the conversation context. This project description was naturally less detailed.</em></blockquote><p>Up to this point, I had completed only Phase 1 with BMAD. Phase 2, planning, then commenced, a mandatory stage of development. During Phase 1, I produced several documents and subsequently divided them into smaller units using sharding. Sharding, analogous to dividing a novel into chapters, involves splitting complex information into manageable sections. Technically, this process restructures documents into an index file and multiple smaller documents. For instance, the comprehensive market analysis was segmented into an index referencing specific market segments, a separate competitive analysis report, and documents containing relevant statistics. This approach allows the agent to process information more efficiently, as it does not need to load large documents into context each time.</p><h3>Phase 2: Planning</h3><h4>Product Requirements Document (PRD)</h4><p><em>(/bmad-bmm-create-prd 1.5 hrs — 10,850,000 tokens — $21.78)<br></em>The BMAD project management agent facilitates the planning phase by generating the Product Requirements Document (PRD). This process integrates analysis-phase documents into 13 structured steps that cover a range of topics. The agent develops the PRD, explores application features, defines success criteria, details user journeys, and reassesses domain and innovation opportunities. Upon completion, the PRD specifies the project type, distinguishes it from comparable applications, and delineates both functional and non-functional requirements.</p><p>Much of the content already came from the previous analysis phase. However, the PM agent asked additional questions, and the option to use extended discovery and party mode was again available. At the end of this process, the PRD was complete, so I could sketch the solution in the next phase.</p><h4>UX Design</h4><p><em>(/bmad-bmm-create-ux-design — 2.5 hrs, 10,580,000 tokens — $21.24)<br></em>An optional workflow in the planning phase was UX design. The UX agent established both user experience patterns and the overall look and feel, guided by the PRD. The agent led a series of steps, including defining experience principles, general user experience, emotional response, UX inspiration, design system decisions, user journey flows, component strategy, consistency patterns, and considerations for responsive design and accessibility. At each stage, extended discovery and party mode were available. To determine the overall user experience, the agent generated HTML mockups for various design directions based on my input. After evaluating these mockups, I selected a design that balanced simplicity with accessibility. The decisive factor was the mockup’s clear contrasts and intuitive navigation, ensuring inclusivity for all user groups. Other designs were not adopted. For user journey flows, the agent produced flowcharts that I visualized using Mermaid.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/906/0*wWKVEl1hs38IeAnd" /></figure><blockquote><em>When working manually with Claude, I was guided in this step to create screens and flows in Figma, which took significantly more time.</em></blockquote><h3>Phase 3: Solution Design</h3><h4>Architecture</h4><p><em>(/bmad-bmm-create-architecture — 2 hrs, 9,790,000 tokens — $19.65)<br></em>In the initial solution design workflow, I made architectural decisions with guidance from the architecture agent, informed by both functional and non-functional requirements. I addressed several categories, such as technology and security, and the agent presented options I could select or augment with my own input. As in earlier workflows, extended discovery and party mode were available. Subsequently, I defined implementation patterns and the overall project structure. The workflow concluded with architecture validation.</p><h4>Epics and Stories</h4><p><em>(/bmad-bmm-create-epics-and-stories — 0.5 hrs, 3,710,000 tokens — $7.45)</em><br>In this workflow, the agent generates actionable epics and stories derived from the PRD, architecture, and UX design. Initially, epics are designed to deliver user value rather than focusing solely on technical milestones. Stories are then created for each epic and subsequently validated. The agent systematically verifies that all requirements are addressed. Each story must include Given/When/Then acceptance criteria, reference specific functional requirements, be executable by a single development agent, build only upon preceding stories, and avoid forward dependencies. Eliminating forward dependencies improves efficiency by preventing delays caused by incomplete tasks.</p><h4>Checking All Documents for Implementation</h4><p><em>(/bmad-bmm-check-implementation-readiness — 0.5 hrs, 8,710,000 tokens — $17.48)<br></em>In the last planning workflow, the agent validated the PRD, UX, architecture, and stories, and checked whether all implementation information was included. In doing so, the agent identified inconsistencies between the epics and stories and the planning documents. I could evaluate and have these corrected. The project was then ready for implementation.</p><h3>Phase 4: Implementation</h3><h4>Sprint Planning</h4><p><em>(/bmad-bmm-sprint-planning — 5 min, 417,200 tokens — $0.83)<br></em>The initial workflow in the implementation phase was sprint planning, which comprised five steps in which I did not intervene. The agent analyzed the epic files, extracted all work items, and established the sprint status structure with automated status detection, generating the sprint status file. Validation and a final report followed, prompting me to review the implementation artifact. Although I could rerun the workflow to manually update detected statuses, this was unnecessary immediately after creation and before any stories were implemented. Agents continued to update statuses automatically during subsequent development. I then created the first story.</p><blockquote><em>The planning was also part of my process when working with Claude. I asked Claude to analyze my previous work and create manageable work packages that I could gradually work through.</em></blockquote><h4>Creating the First Story</h4><p><em>(/bmad-bmm-create-story — 15 min — 3,002,800 tokens — $6.03)<br></em>Initially, the agent set the epic status to ‘in progress,’ while other epics remained in ‘backlog.’ The agent then loaded and analyzed all core artifacts, providing suggestions for improvement and opportunities for further optimization. I supplied additional instructions and information regarding the story. Based on this input, the agent generated the first story for my review. Following my review, the implementation of the first story began.</p><h4>Implementing the First Story</h4><p><em>(/bmad-bmm-dev-story — 2 hrs — 12,537,200 tokens — $25.18)<br></em>Because the project was developed in Xcode, the development agent recommended creating the project manually, although automatic generation was also feasible. I opted for manual setup. I also informed the agent that the project would utilize the Concurrency Approachable and provided the necessary details. The agent automated several tasks, such as creating unit tests and implementing story tasks. My involvement was needed when adding Swift packages to support modularity. The agent then executed the unit tests and successfully completed them. Upon completion, all tasks and subtasks associated with the story were marked as finished.</p><p>Prior to initiating the development agent’s code review, I performed a functional test in the simulator and conducted my own code review. I identified that the packages did not implement Approachable Concurrency, that the color names were not generic, and that the unit tests lacked @MainActor annotations. The agent overlooked these issues because it had not run the unit tests within the packages; instead, they were duplicated in the main project. I removed redundant tests from the main project and developed a comprehensive test plan that includes all unit tests across the main project and its packages. The agent’s code review then proceeded, ideally using a second-language model, though one was not available to me at the time.</p><blockquote><em>In my work without BMAD, I used Xcode Code Assist with Claude and wrote source code by hand, following the work packages created by Claude. In most cases, these already contained example code. I always communicated changes to Claude. This was, of course, significantly slower, but I naturally also knew more about my codebase.</em></blockquote><h4>Code Review of the First Story</h4><p><em>(/bmad-bmm-code-review — 0.5 hrs — 2,500,000 tokens — $5.02)<br></em>The adversarial code review identified issues of varying severity, ranging from critical to low-priority. For instance, inconsistencies were detected in the generic color names I had assigned. I specified to the development agent which issues should be addressed and which could remain unresolved, providing justifications for the latter and requesting corresponding adjustments to the requirements. Once the issues were resolved and requirements updated, the agent marked the story as ‘Done.’ I then verified the implementation and committed the changes.</p><blockquote><em>In my previous process, I asked Xcode Code Assist with Claude for a code review, which also took longer because I had to mark the new source code. Later, I always used Claude Code in the terminal for this.</em></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*v6wgiGLI36hGZtfJGmjGuw.jpeg" /><figcaption>Created Idea, PRD, UX Design, Architecture, Implementation Docs, and initial app story unit tests, and validated requirements.</figcaption></figure><h3>What’s Next?</h3><p>In subsequent stages, which I will document later, I will continue alternating between the Create Story (/bmad-bmm-create-story), Dev Story (/bmad-bmm-dev-story), and Code Review (/bmad-bmm-code-review) workflows until all epics and stories are completed. After each epic, an Epic Retrospective can be generated (/bmad-bmm-create-story). Additionally, I can check the sprint status (/bmad-bmm-sprint-status) at any point or request a course correction (/bmad-bmm-correct-course) if significant changes are necessary.</p><h3>Preliminary Summary</h3><p>The development of my break app using the BMAD method encompassed four primary phases: Analysis, Planning, Solution Design, and Implementation. During the optional analysis phase, I engaged in guided brainstorming, conducted extensive market and domain research, and produced a detailed product brief. The planning phase involved creating a PRD, designing the user experience with HTML mockups and flowcharts, and making key architectural decisions. In the solution design phase, I developed actionable epics and stories with well-defined acceptance criteria.</p><p>Implementation was executed by specialized agents responsible for sprint planning, story creation, development, and code reviews. Compared with manual development with Claude alone, BMAD provided substantially greater structure and efficiency, though it demanded significant token resources — over 87 million tokens, amounting to approximately $175 — to complete the first story of the initial epic. The method was especially advantageous for systematic documentation and decomposing complex tasks, whereas manual processes afforded greater control over the codebase but were considerably more time-intensive.</p><p>A key insight is that a single Claude Pro account is insufficient, as the token-intensive workflows necessitate substantially more resources than the default allocation provides.</p><p>In <a href="https://medium.com/@simonbogutzky/from-idea-to-application-part-2-the-real-cost-of-bmad-and-choosing-the-right-llm-a1d419d3f46d">Part 2</a>, I examine the real cost of running BMAD across a full 20-story iOS project, compare four LLMs for implementation quality, and share my overall takeaways after completing multiple stories — including what I gained and what I lost compared to my previous workflow.</p><p>I am interested in learning about others’ experiences with AI-supported agile development frameworks. Please share your insights in the comments.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5765d981283f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Building the Same App in SwiftUI, Kotlin Multiplatform, and Flutter — What 281 vs.]]></title>
            <link>https://medium.com/@simonbogutzky/building-the-same-app-in-swiftui-kotlin-multiplatform-and-flutter-what-281-vs-200238dac555?source=rss-e85e115a0166------2</link>
            <guid isPermaLink="false">https://medium.com/p/200238dac555</guid>
            <category><![CDATA[mobile-development]]></category>
            <category><![CDATA[kotlin-multiplatform]]></category>
            <category><![CDATA[flutter]]></category>
            <category><![CDATA[swiftui]]></category>
            <category><![CDATA[cross-platform]]></category>
            <dc:creator><![CDATA[Dr. Simon Bogutzky]]></dc:creator>
            <pubDate>Wed, 14 Jan 2026 14:30:07 GMT</pubDate>
            <atom:updated>2026-02-05T18:45:56.732Z</atom:updated>
            <content:encoded><![CDATA[<h3>Building the Same App in SwiftUI, Kotlin Multiplatform, and Flutter — What 281 vs. 75 Lines of Code Teaches Us</h3><p>Are you wondering which mobile framework is best for your next project? Instead of comparing feature lists and benchmarks, I built the same app three times: once in native SwiftUI, once in Kotlin Multiplatform with Compose Multiplatform, and once in Flutter. The results surprised me.</p><p>This isn’t another theoretical comparison. I implemented “WeSplit” — a bill-splitting calculator from the “100 Days of SwiftUI” tutorial — in all three frameworks and documented what I learned about code complexity, developer experience, and the real trade-offs you’ll face in production.</p><h3>What WeSplit Does</h3><p>Before diving into the comparison, let’s understand what we’re building. WeSplit is a simple bill-splitting calculator that demonstrates core mobile development concepts:</p><ul><li>Takes a bill amount with localized currency formatting</li><li>Let users select the number of people (2–99)</li><li>Offers tip percentage options (0%, 10%, 15%, 20%, 25%)</li><li>Calculates the amount each person should pay</li><li>Handles navigation between screens</li><li>Manages keyboard focus and input validation</li></ul><p>It’s simple enough to build in an afternoon yet complex enough to reveal how each framework handles real-world challenges such as state management, navigation, and platform integration.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gIJnq4nbkEnRYSRqnjX-0g.png" /><figcaption>Three implementations of WeSplit showing identical functionality across SwiftUI, KMP/Compose, and Flutter</figcaption></figure><h3>The 75 vs. 281 Line Reality</h3><p>Here’s what surprised me most: implementing identical functionality resulted in dramatically different code sizes.</p><ul><li><strong>SwiftUI</strong>: 75 lines</li><li><strong>Flutter</strong>: 238 lines</li><li><strong>KMP/Compose</strong>: 281 lines</li></ul><p>SwiftUI needs roughly one-third the code of Flutter and one-quarter of KMP/Compose. That’s not a minor difference — that’s SwiftUI finishing the app while the other frameworks are still setting up navigation.</p><p>But before you conclude “SwiftUI wins,” let’s understand what those extra 200+ lines in KMP/Compose actually buy you. Sometimes, more code means better architecture, explicit behavior, and easier maintenance at scale.</p><h3>Understanding the Architecture Differences</h3><h4>SwiftUI: Everything in One Place</h4><p>SwiftUI lets you build this entire app in a single file. Here’s the core structure:</p><pre>struct ContentView: View {<br>  @State private var checkAmount = 0.0<br>  @State private var numberOfPeople = 2<br>  @State private var tipPercentage = 20<br>  <br>  @FocusState private var amountIsFocused: Bool<br>  <br>  var totalPerPerson: Double {<br>    let peopleCount = Double(numberOfPeople + 2)<br>    let tipSelection = Double(tipPercentage)<br>    let tipValue = checkAmount / 100 * tipSelection<br>    let grandTotal = checkAmount + tipValue<br>    return grandTotal / peopleCount<br>  }<br><br>  var body: some View {<br>    NavigationStack {<br>      Form {<br>        // UI implementation<br>      }<br>    }<br>  }<br>}</pre><p>Everything lives in one `ContentView`: the state, the calculation, and the UI. The computed property `totalPerPerson` automatically recalculates when state changes. This is SwiftUI’s philosophy: make simple things trivially simple.</p><p>For a small app like WeSplit, this is perfect. But what if you’re building something larger?</p><h4>KMP/Compose: Built for Growth</h4><p>Kotlin Multiplatform takes a different approach. Here’s how the same app starts:</p><pre>object NavigationRoutes {<br>  const val HOME = &quot;home&quot;<br>  const val SELECT_PEOPLE = &quot;select_people&quot;<br>}<br><br>object AppConstants {<br>  const val DEFAULT_NUMBER_OF_PEOPLE = 2<br>  const val DEFAULT_TIP_PERCENTAGE = 20<br>}<br><br>@Composable<br>fun App() {<br>  val navController = rememberNavController()<br>  NavHost(navController = navController, startDestination = HOME) {<br>    composable(HOME) { HomeScreen(navController) }<br>    composable(SELECT_PEOPLE) { SelectPeopleScreen(navController) }<br>  }<br>}</pre><p>Notice what’s happening here: constants are extracted, navigation is explicit, and screens are separate composables. This adds verbosity but also makes intent clear and provides a structure that scales.</p><p>When I started adding the second screen, SwiftUI’s implicit navigation felt magical. KMP/Compose’s explicit navigation felt verbose. But by the time I thought about adding a third screen, I appreciated having navigation routes defined in one place.</p><h4>Flutter: The Middle Ground</h4><p>Flutter takes a pragmatic middle path:</p><pre>class _WeSplitState extends State&lt;WeSplit&gt; {<br>  double checkAmount = 0.0;<br>  int numberOfPeople = 2;<br>  <br>  final TextEditingController _amountController = TextEditingController();<br>  final FocusNode _amountFocusNode = FocusNode();<br><br>  @override<br>  void initState() {<br>    super.initState();<br>    _amountController.addListener(_onAmountChanged);<br>   }<br><br>  @override<br>  void dispose() {<br>    _amountController.dispose();<br>    _amountFocusNode.dispose();<br>    super.dispose();<br>  }<br>}</pre><p>Flutter requires explicit lifecycle management. You create controllers, register listeners, and manually clean up resources. This is more work than SwiftUI but less structured than KMP/Compose.</p><p>The catch? Forget to call `dispose()` and you’ve got a memory leak. SwiftUI handles this automatically, and KMP/Compose manages it through composition.</p><h3>State Management: Where Things Get Interesting</h3><h4>SwiftUI: Property Wrappers Do the Heavy Lifting</h4><p>State management in SwiftUI feels almost invisible:</p><pre>@State private var checkAmount = 0.0<br>@State private var numberOfPeople = 2<br>@State private var tipPercentage = 20<br><br>@FocusState private var amountIsFocused: Bool</pre><p>That’s it. The `@State` wrapper makes views reactive to changes in those values, the `$` syntax creates two-way bindings, and SwiftUI automatically tracks what depends on what. When `checkAmount` changes, the UI updates. When the tip percentage changes, `totalPerPerson` recalculates.</p><p>The specialized `@FocusState` wrapper deserves attention. It manages keyboard focus declaratively — no manual focus managers, no imperative API calls. Just declare the state and bind it.</p><h4>KMP/Compose: Explicit Control</h4><p>Compose makes you write out what SwiftUI handles automatically:</p><pre>var numberOfPeople by remember { mutableStateOf(DEFAULT_NUMBER_OF_PEOPLE) }<br>var checkAmount by remember { mutableStateOf(0.0) }<br>val totalPerPerson by remember(numberOfPeople, checkAmount, tipPercentage) {<br>  derivedStateOf {<br>    val peopleCount = numberOfPeople.toDouble()<br>    val tipValue = checkAmount / 100 * tipPercentage<br>    val grandTotal = checkAmount + tipValue<br>    grandTotal / peopleCount<br>  }<br>}</pre><p>See the difference? Compose uses `derivedStateOf` with explicit dependencies. This means `totalPerPerson` only recalculates when `numberOfPeople`, `checkAmount`, or `tipPercentage` change — not on every recomposition.</p><p>This verbosity is actually a feature. You have fine-grained control over when calculations run, which becomes critical for complex apps with expensive computations.</p><h4>Flutter: Manual Labor</h4><p>Flutter requires the most hands-on management:</p><pre>final TextEditingController _amountController = TextEditingController();<br>final FocusNode _amountFocusNode = FocusNode();<br><br>void _onAmountChanged() {<br>  setState(() {<br>    checkAmount = double.tryParse(_amountController.text) ?? 0.0;<br>  });<br>}<br><br>@override<br>void dispose() {<br>  _amountController.dispose();<br>  _amountFocusNode.dispose();<br>  super.dispose();<br>}</pre><p>You create controllers, wire up listeners, parse values, and remember to dispose of everything. Miss the cleanup, and you’ve introduced a memory leak.</p><p>This imperative approach gives you control, but it’s also work that SwiftUI and Compose handle for you. For a simple app, it feels like an unnecessary ceremony. For a complex app, it has explicit control over resources.</p><h3>Navigation: From Magic to Manual</h3><h4>SwiftUI: It Just Works</h4><p>Remember how I said SwiftUI makes simple things simple? Navigation is the perfect example:</p><pre>Picker(&quot;Number of people&quot;, selection: $numberOfPeople) {<br>  ForEach(2 ..&lt; 100) {<br>    Text(&quot;\($0) people&quot;)<br>  }<br>}<br>.pickerStyle(.navigationLink)</pre><p>That’s the entire navigation implementation. One modifier — `.navigationLink` — and SwiftUI handles pushing a new screen, animating the transition, adding a back button, and managing the navigation stack.</p><p>When the user selects a value, the `$numberOfPeople` binding automatically updates. No manual navigation controller, no route management, no state passing between screens. It feels like magic because it abstracts away all the complexity.</p><p>The trade-off? You have less explicit control. Want custom transition animations? Need to track navigation state? SwiftUI’s implicitness becomes a limitation.</p><h4>Flutter: Clear and Predictable</h4><p>Flutter takes the opposite approach — everything is explicit:</p><pre>final result = await Navigator.push&lt;int&gt;(<br>  context,<br>  MaterialPageRoute(<br>    builder: (context) =&gt; NumberOfPeoplePicker(<br>      selectedNumber: numberOfPeople,<br>    ),<br>  ),<br>);<br><br>if (result != null) {<br>  setState(() {<br>    numberOfPeople = result;<br>  });<br>}</pre><p>This code clearly shows what happens: push a new route, wait for a result, update the state if we got one. The async/await pattern makes the data flow obvious, and type safety (`&lt;int&gt;`) ensures you get back what you expect.</p><p>It’s more code than SwiftUI, but every step is visible. There’s no magic — just straightforward imperative navigation.</p><h4>KMP/Compose: Structure Over Brevity</h4><p>Compose requires the most setup:</p><pre>NavHost(navController = navController, startDestination = HOME) {<br>  composable(HOME) {<br>    HomeScreen(<br>      navController = navController,<br>      onNavigateToSelectPeople = {<br>        navController.navigate(SELECT_PEOPLE)<br>      }<br>    )<br>  }<br><br>  composable(SELECT_PEOPLE) {<br>    SelectPeopleScreen(<br>      navController = navController,<br>      currentSelection = numberOfPeople,<br>      onPeopleSelected = { selected -&gt;<br>        numberOfPeople = selected<br>        navController.popBackStack()<br>      }<br>    )<br>  }<br>}</pre><p>This navigation graph approach is verbose for a two-screen app. But imagine having 20 screens. That’s when this structure pays off — all your routes in one place, navigation paths explicit and searchable, and screen dependencies clear.</p><h3>UI Implementation: Handling User Input</h3><p>Each framework handles form input differently. Here’s what implementing the amount text field taught me.</p><h4>SwiftUI: Built-in Currency Formatting</h4><pre>TextField(&quot;Amount&quot;, value: $checkAmount, <br>  format: .currency(code: Locale.current.currency?.identifier ?? &quot;USD&quot;))<br>.keyboardType(.decimalPad)<br>.focused($amountIsFocused)</pre><p>SwiftUI includes currency formatting out of the box. The `format` parameter handles localization automatically, displaying $ for US users, € for European users, and so on. Three modifiers and you’re done.</p><h4>KMP/Compose: Manual Validation</h4><pre>OutlinedTextField(<br>  value = amountText,<br>  onValueChange = { newValue -&gt;<br>    if (newValue.isEmpty() || newValue.matches(Regex(&quot;^\\d+(\\.\\d{0,2})?$&quot;))) {<br>      amountText = newValue<br>      checkAmount = newValue.toDoubleOrNull() ?: 0.0<br>    }<br>  },<br>  leadingIcon = { Text(currencySymbol) },<br>  keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Decimal)<br>)</pre><p>Compose requires explicit regex validation. That pattern `^\\d+(\\.\\d{0,2})?$` ensures users can only enter valid decimal numbers with up to two decimal places. It’s more work than SwiftUI, but you know exactly what inputs are allowed.</p><h3>Flutter: Controllers and Formatters</h3><pre>TextField(<br>  controller: _amountController,<br>  focusNode: _amountFocusNode,<br>  decoration: InputDecoration(<br>    labelText: &#39;Amount&#39;,<br>    prefixText: NumberFormat.simpleCurrency().currencySymbol,<br>  ),<br>    keyboardType: TextInputType.numberWithOptions(decimal: true),<br>    inputFormatters: [<br>      FilteringTextInputFormatter.allow(RegExp(r&#39;^\d+\.?\d{0,2}&#39;)),<br>    ],<br>  onChanged: (value) {<br>    setState(() {<br>      checkAmount = double.tryParse(value) ?? 0.0;<br>    });<br>  },<br>)</pre><p>Flutter combines controller management, input formatters, and manual state updates. It’s the most verbose but gives you explicit control at every step.</p><h3>Platform Integration: The Localization Challenge</h3><p>Here’s where the frameworks reveal their platform strategy.</p><h4>SwiftUI: Zero Configuration</h4><pre>.currency(code: Locale.current.currency?.identifier ?? &quot;USD&quot;)</pre><p>One line. SwiftUI taps directly into iOS localization. It knows your device locale, the currency you use, and how to format numbers. Zero configuration, zero dependencies.</p><h4>KMP/Compose: Proper Abstraction</h4><pre>// commonMain<br>expect fun getCurrencySymbol(): String<br>expect fun formatCurrency(amount: Double): String<br><br>// iosMain<br>actual fun getCurrencySymbol(): String {<br>  return NSLocale.currentLocale.currencySymbol ?: &quot;$&quot;<br>}<br><br>// androidMain<br>actual fun getCurrencySymbol(): String {<br>  return Currency.getInstance(Locale.getDefault()).symbol<br>}</pre><p>KMP’s expect/actual pattern is more work, but it’s the right approach for true cross-platform code. You write the interface once, then implement it for each platform. Your business logic stays shared, platform details stay isolated.</p><p>This is where those extra 200 lines start making sense — you’re building proper abstractions, not quick hacks.</p><h4>Flutter: Package Dependency</h4><pre>final format = NumberFormat.currency(<br>  symbol: NumberFormat.simpleCurrency().currencySymbol,<br>  decimalDigits: 2<br>);</pre><p>Flutter relies on the `intl` package. It works well and provides a consistent API, but you’re adding an external dependency for something that’s built into iOS and Android.</p><h3>What About Performance?</h3><p>For an app this size, performance differences are negligible. But the approaches reveal how each framework thinks about optimization.</p><p><strong>SwiftUI</strong> uses computed properties that are automatically recalculated. SwiftUI’s view diffing is efficient enough that you don’t need to think about optimization for most apps.</p><p><strong>KMP/Compose</strong> gives you `derivedStateOf` to explicitly control when calculations run. For simple apps, it’s overkill. For complex apps with expensive computations, it’s essential.</p><p><strong>Flutter</strong> recalculates getters on every access without memoization. For WeSplit’s simple math, this doesn’t matter. For complex calculations or data transformations, you’d need to add your own caching.</p><p>Runtime performance? All three are fast enough for this app. SwiftUI is native iOS, KMP/Compose compiles to native code on both platforms, and Flutter’s Impeller rendering is consistently performant across platforms.</p><blockquote>Since Flutter 3.29, Impeller has been the default on iOS and is enabled by default on Android API 29+.</blockquote><h3>Testing and Maintainability</h3><p><strong>SwiftUI’s</strong> single-file structure is easiest to understand but hardest to test in isolation. Preview provides instant visual feedback, which partially compensates for limited testability.</p><p><strong>KMP/Compose</strong> has the best separation. Composables are pure functions that are easy to unit-test. Platform-specific code is properly isolated. Constants are extracted. It’s built for scaling.</p><p><strong>Flutter</strong> falls in the middle. Widget testing is well-supported, but the controller pattern adds testing complexity. Remember to dispose of resources in tests, just as in production code.</p><p>For a small app, SwiftUI’s simplicity wins. For a large app with multiple teams, KMP/Compose’s structure becomes valuable.</p><h3>The Developer Experience Reality</h3><p>Let me be honest about what it’s actually like to build with each framework.</p><h4>SwiftUI</h4><p>I wrote the SwiftUI version in about 1 hour. Xcode’s preview showed changes instantly. When something didn’t work, error messages were usually helpful. The integrated documentation made discovering APIs easy.</p><p>The catch? You need a Mac and Xcode. And you’re building for iOS only (unless you expand to other Apple platforms).</p><h3>KMP/Compose</h3><p>The KMP version took about 3 hours. Much of that was setting up the navigation structure and the expect/actual pattern for currency formatting. IntelliJ IDEA’s autocomplete helped, but I frequently referenced documentation.</p><p>Once the structure was in place, adding features became methodical. The explicit architecture meant I always knew where things should go.</p><p>The learning curve is real. Kotlin’s syntax differs from Swift and Dart, and understanding expect/actual requires wrapping your head around a new concept.</p><h4>Flutter</h4><p>Flutter took about 2 hours. The hot reload is incredibly fast — probably the best developer experience feature across all three frameworks. VS Code integration worked smoothly.</p><p>The manual controller management slowed me down. I had to think about disposal, listener registration, and state updates that SwiftUI handles automatically.</p><p>The `intl` package added a step, but pub.dev has mature packages for most needs.</p><h3>Making the Choice: What Should You Actually Use?</h3><p>Here’s my honest take based on building the same app three times.</p><h4>Choose SwiftUI When:</h4><p>You’re building for iOS (or the Apple ecosystem), and you value development speed. The 75-line implementation isn’t just about less typing — it’s about faster iteration, fewer decisions, and getting to market sooner.</p><p>SwiftUI is also the right choice when native iOS integration matters. Direct access to system APIs, automatic localization, and deep platform integration are available at no cost.</p><p>If your team already knows Swift, the learning curve is manageable. SwiftUI’s syntax differs from UIKit&#39;s, but the language is familiar.</p><h4>Choose KMP/Compose When:</h4><p>You need native performance on both iOS and Android while sharing business logic. The extra 200 lines aren’t overhead — they’re proper architecture for code sharing.</p><p>KMP/Compose makes sense for complex apps that will scale. Explicit navigation, separated concerns, and platform abstraction pay dividends as your app grows to dozens of screens and multiple team members.</p><p>If your team knows Kotlin, you’re already ahead. If you’re willing to invest in learning, Kotlin’s modern language features make it worthwhile.</p><p>The flexibility to target desktop or web later is a bonus. KMP can compile to JVM (desktop), JavaScript (web), and native (iOS/Android/others).</p><h4>Choose Flutter When:</h4><p>You need rapid cross-platform development with a mature ecosystem. Flutter’s 238 lines get you to iOS and Android fast, and the hot reload experience is genuinely excellent.</p><p>Flutter works well for MVPs and startups that need to validate ideas quickly. The large package ecosystem means you’re not building everything from scratch.</p><p>Budget constraints favor Flutter. One codebase, one team, two platforms. The economics are simple.</p><p>The trade-offs? Manual resource management adds complexity, and Dart is rarely used outside Flutter (though it’s not hard to learn).</p><h3>What I Learned</h3><p><strong>SwiftUI excels at elegance.</strong> The 75-line implementation proves that for iOS-only apps, SwiftUI makes development remarkably fast and maintainable. The framework handles so much automatically that you focus on features, not infrastructure.</p><p><strong>KMP/Compose invests in architecture.</strong> Those 281 lines reflect intentional structure: explicit navigation, platform abstraction, and proper separation of concerns. For apps that will grow and evolve, this foundation becomes valuable.</p><p><strong>Flutter balances pragmatism.</strong> With 238 lines of code, strong tooling, and a mature ecosystem, Flutter delivers practical cross-platform development. It’s not the most elegant or the most structured, but it gets the job done efficiently.</p><p><strong>The real differences emerge at scale.</strong> For a simple app like WeSplit, all three frameworks work well. You’d choose based on platform targets, team skills, and development speed. The architectural differences matter more when you’re building something complex with multiple teams.</p><p><strong>Platform-specific features can’t be ignored.</strong> SwiftUI’s native integration is unmatched for iOS-only apps. But KMP and Flutter’s ability to share code across platforms changes the economics for multi-platform development.</p><h3>Your Turn</h3><p>I’ve shown you what 75 vs. 238 vs. 281 lines of code actually means in practice. Now it’s your choice.</p><p>Start with your platform requirements. iOS-only? SwiftUI is hard to beat. Need both iOS and Android? KMP/Compose or Flutter makes more sense. Think about your team’s existing skills. Learning a new framework takes time — factor that into your timeline.</p><p>Consider your app’s complexity. Simple apps favor SwiftUI’s elegance. Complex apps benefit from KMP/Compose’s structure. Rapid prototypes work well with Flutter’s speed.</p><p>Most importantly, remember that all three frameworks are mature and capable. Your choice matters less than consistent execution. Pick one, learn it well, and build something people love.</p><p><em>The complete code for all three implementations is available in my GitHub repository: <br></em><a href="https://github.com/simonbogutzky/wesplit-swiftui"><em>https://github.com/simonbogutzky/wesplit-swiftui</em></a><em><br></em><a href="https://github.com/simonbogutzky/wesplit-kmp"><em>https://github.com/simonbogutzky/wesplit-kmp</em></a><em><br></em><a href="https://github.com/simonbogutzky/wesplit-flutter"><em>https://github.com/simonbogutzky/wesplit-flutter</em></a></p><p><em>Have you built the same app in multiple frameworks? Share what you learned in the comments.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=200238dac555" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Vibe Coding for Mobile Developers: Promises, Pitfalls, and a Path Forward]]></title>
            <link>https://medium.com/@simonbogutzky/vibe-coding-for-mobile-developers-promises-pitfalls-and-a-path-forward-2d1997a0076c?source=rss-e85e115a0166------2</link>
            <guid isPermaLink="false">https://medium.com/p/2d1997a0076c</guid>
            <category><![CDATA[mobile-app-development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[ios-development]]></category>
            <category><![CDATA[code-quality]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Dr. Simon Bogutzky]]></dc:creator>
            <pubDate>Fri, 10 Oct 2025 10:59:32 GMT</pubDate>
            <atom:updated>2025-10-10T10:59:32.101Z</atom:updated>
            <content:encoded><![CDATA[<p>Are you thinking about letting AI write your iOS app? The productivity gains are real, but so are the hidden costs. This guide will show you how to use AI coding tools without losing code quality, security, or your own skills.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mbsS4nKd6T33tpGHg2Y3bQ.png" /><figcaption>Balanced scale with glowing AI chip on left, human developer on right, perfectly balanced, modern minimalist style, light background, blue-purple vs warm orange-yellow color scheme, subtle code elements, professional tech illustration, 16:9 — Craiyon</figcaption></figure><h3>Understanding Vibe Coding</h3><p>In February 2025, Andrej Karpathy created the term “Vibe Coding” with a bold statement: “Fully give in to the vibes, embrace exponentials, and forget that the code even exists.” This represents a significant shift in our software development approach.</p><p>Traditional development works like this: write code, test it, fix bugs, and repeat. Vibe coding is different: describe what you want, accept the AI’s output, test the result, and resolve problems by giving error messages back to the AI. The goal is speed over understanding and quick prototypes over deep knowledge.</p><h3>The Productivity Promise</h3><p>The numbers look good. Studies show AI coding tools can save 70% of time on boilerplate code, 60% on test creation, and 55% on API integration. McKinsey research shows 30–40% productivity gains across different tasks.</p><p>Real examples make this stronger. In Y Combinator’s Winter 2025 batch, 25% of startups built products with 95% AI-generated code and made $1–10M in revenue. Developer Akhil Dakinedi built his iOS app “Poker Slam” in just 10–15 hours using vibe coding.</p><p>But these gains aren’t the same everywhere. The truth is more complex.</p><h3>When AI Works Best (and Worst)</h3><p>Understanding where AI excels and where it falls short is crucial for achieving good results. The gains largely depend on your project type and task difficulty.</p><p>For new projects, AI works best. Simple, clear tasks get 35–40% productivity gains. Complex tasks that need human thinking still get 10–15% gains. Starting fresh allows AI to create code without the issues of legacy projects.</p><p>Old projects are different. Simple tasks on existing code yield 15–20% gains, whereas complex work on legacy systems shows almost no improvement, at 0–10%. Old code and technical debt limit what AI can do.</p><h3>The Vibe Coding Hangover</h3><p>By September 2025, the industry faced a hard truth. Developers spent 30–40% of their time on “vibe fixing” — cleaning up AI code that initially worked but became difficult to maintain. A new job appeared: “Vibe Code Cleanup Specialist.”</p><p>The pattern was clear. Fast creation doesn’t mean easy maintenance. Code that passes tests may hide design problems, performance issues, or security holes that only show up in production or when adding features.</p><h3>Security: The Hidden Risk</h3><p>Georgetown University found a big problem: 50% of AI-generated code has security vulnerabilities. Worse, they discovered that developers feel more secure while writing less secure code.</p><p>For mobile developers handling sensitive data such as banking, health records, or personal information, this poses a significant risk. AI tools don’t have the security awareness that experienced developers bring to authentication, data encryption, and API security.</p><h3>Mobile-Specific Challenges</h3><p>iOS and Android development present unique challenges for AI coding tools. New frameworks come faster than AI training data. Swift 6.2 features, iOS 18 APIs, and the latest Jetpack Compose patterns are unknown to most AI models.</p><p>Complex mobile patterns often confuse AI. Delegate patterns in UIKit, app lifecycle management, and memory management require a deep understanding that current AI struggles with. Battery life and thermal management require testing on real devices, which AI cannot replicate.</p><p>Apple announced Swift Assist at WWDC 2024, but it’s still not available as of September 2025. Third-party tools like Alex (an iOS-focused AI coding assistant) looked promising, but it was acquired by OpenAI in September 2025 and subsequently shut down for new users. The mobile AI coding world is still messy and young.</p><h3>The Human Cost: Skill Loss</h3><p>The most significant issue with vibe coding is the loss of basic development skills. Junior developers face the greatest challenge, learning from AI instead of experienced mentors. One developer said it clearly: “I notice how dumb I’ve become since fully relying on LLMs.”</p><p>When AI replaces human mentoring, the next generation of developers might miss the foundational skills that make them effective problem-solvers. Understanding why code works is just as important as making it work.</p><h3>Building AI-Friendly Codebases</h3><p>AI works best with well-organized projects. Good practices that help both humans and AI include:</p><ul><li>Document your standards and practices</li><li>Keep development environments simple and easy to set up</li><li>Make testing automatic and easy to access</li><li>Create clear module boundaries with defined interfaces</li><li>Write clear tasks with specific requirements and success criteria</li></ul><p>The key point is that if your codebase is messy for humans, AI makes it worse. If it’s clean for humans, AI makes it better.</p><h3>The C.O.D.E.S. Framework: A Professional Approach</h3><p>Instead of rejecting or blindly using AI coding tools, successful teams must develop structured approaches. The C.O.D.E.S. framework brings together best practices from teams using AI tools professionally.</p><h3>C — Collective Prompt Libraries &amp; Rules</h3><p>Teams create reusable, tested prompts that include platform-specific patterns and company standards. A rules file (.cursorrules, CLAUDE.md, or CONVENTIONS.md) that AI tools load automatically keeps things consistent without repeating instructions each time.</p><p>For iOS development, your prompt library might include: “Generate SwiftUI view for [feature] following our architecture guidelines.” These prompts get better as your team learns what works and what creates problems.</p><h3>O — Organized Verification</h3><p>Verification happens at three levels.</p><p><strong>Automated verification</strong> runs SwiftLint on all AI-generated code, requires unit test coverage minimums, and uses static analysis tools like SonarQube.</p><p><strong>Manual verification</strong> includes security audit checklists for authentication and networking code, performance checks for critical paths, and accessibility testing with VoiceOver.</p><p><strong>Staged rollout</strong> finishes the verification process. Code moves from development to staging with complete tests before reaching production, only after human approval. Each stage acts as a quality gate.</p><h3>D — Defined Standards</h3><p>Being clear about where AI helps and where humans must lead stops the most significant mistakes. Your standards should list exactly what AI can do: SwiftUI view scaffolding, data model creation from API specs, [unit test creation], code documentation, and networking boilerplate with required review.</p><p>Human-only areas require equal clarity: authentication and authorization logic, payment processing, performance-critical algorithms, custom animations needing optimization, and production deployment settings. These boundaries safeguard your most critical code from AI limitations.</p><h3>E — Established Review Processes</h3><p>Code review becomes more critical when AI creates code. Standard review questions stay the same: Is functionality correct? Are tests there? Is the style consistent?</p><p><strong>AI-code review needs more questions:</strong> Are APIs current or old? Is memory management safe? Is async code thread-safe? Does it support multiple languages and dark mode?</p><p><strong>Code review is now the most critical skill.</strong> Reviewing AI output needs different skills than reviewing human code. AI can be wrong in ways that look right at first glance. Understanding what the code should do matters more than checking syntax.</p><p>The most valuable developers won’t be the best at writing prompts. They’ll be the ones with the best sense of when to use AI versus human skills.</p><p><strong>Specialized reviewers</strong> for security, performance, and accessibility should check AI-generated code in their areas. AI can appear correct while being wrong, and minor bugs can hide in code that looks good.</p><h3>S — Skilled Mentoring</h3><p>Structured onboarding prevents junior developers from adopting poor coding practices. A structured program should cover the basics: how LLMs work and their limits, basic prompt writing techniques, platform-specific patterns and team prompts, common AI mistakes to watch for, code review skills for AI output, including security risks and performance problems, and practical application of the C.O.D.E.S. framework with your team’s prompt library.</p><p><strong>Ongoing learning</strong> continues with regular knowledge-sharing meetings and discussions about AI mistakes, where teams learn what went wrong and why. Tool updates and continuous education keep skills current as AI capabilities change.</p><h3>The Golden Middle Path</h3><p>Vibe coding offers real productivity gains but also significant risks in security, maintenance, and skill development. The answer is: organized, professional use rather than blind adoption or complete rejection.</p><p>Treat AI like a talented junior developer. It’s useful for quick prototypes and boilerplate code, but requires close monitoring. Human skills are still needed for architecture decisions, security work, and performance-critical parts.</p><p>The future uses both approaches. AI accelerates repetitive tasks and the creation of first drafts. Humans provide judgment, security awareness, and design vision. The most successful developers will master both.</p><p>Are you ready to use AI coding tools professionally in your mobile development work? Start with one part of the C.O.D.E.S. framework. Build your prompt library. Set up verification steps. Define clear boundaries. Your future self — and your codebase — will thank you.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2d1997a0076c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Ensuring Proper Localization in Modular Swift Apps]]></title>
            <link>https://medium.com/@simonbogutzky/ensuring-proper-localization-in-modular-swift-apps-797fb56d9743?source=rss-e85e115a0166------2</link>
            <guid isPermaLink="false">https://medium.com/p/797fb56d9743</guid>
            <category><![CDATA[swift]]></category>
            <category><![CDATA[swift-package]]></category>
            <dc:creator><![CDATA[Dr. Simon Bogutzky]]></dc:creator>
            <pubDate>Mon, 03 Feb 2025 16:10:36 GMT</pubDate>
            <atom:updated>2025-02-03T16:28:07.312Z</atom:updated>
            <content:encoded><![CDATA[<p>Does your Swift package fail to display localized content correctly? Localization issues in modular Swift apps often arise due to misconfigured settings or missing resources. This guide will show you how to configure localization properly so your SwiftUI views display the correct language every time.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/683/1*6Da2HZ-sNzTif-q3eW_1Xg.jpeg" /></figure><h4>Declaring Default Localization in the Package</h4><p>To ensure proper localization, specify the default localization in each package’s <em>Package.swift</em> file:</p><pre>let package = Package(<br> name: &quot;ExamplePackage&quot;,<br> defaultLocalization: &quot;en&quot;, // Default language of the package<br> platforms: [<br> .iOS(.v15)<br> ],<br> …<br>)</pre><p>This setting ensures that the package falls back to the specified default if a device is set to an unsupported language or the app target does not support the device language. Therefore, align localization settings across the app and packages to avoid inconsistencies.</p><h4>Ensuring Localized Resources Exist in the App Target</h4><p>Even with localized packages, your app must include at least one localized resource for proper functionality. A String Catalog in the app target is my recommended approach.</p><blockquote>A String Catalog is not shown as a localized resource in the App target.</blockquote><p>Alternatively, you can enable mixed localizations in <em>Info.plist</em> by setting <em>CFBundleAllowMixedLocalizations</em> to <em>YES</em>. However, this can cause language inconsistencies. For example, if the device is set to French, but the app only supports English, while a package supports French and English, parts of the app may appear in different languages.</p><h4>Conclusion</h4><p>To ensure consistent localization, set the default language in each package, align localization settings, and include a localized resource in the app. While mixed localizations are an option, they should be used cautiously to prevent inconsistencies. These best practices will help your modular Swift app deliver a seamless multilingual experience.</p><p>Are you encountering difficulties using localized strings and image assets from a Swift package in your SwiftUI views, especially when nested within another package? <a href="https://medium.com/@simonbogutzky/solving-localization-and-asset-issues-in-swift-packages-for-swiftui-views-2378686bdd9e">https://medium.com/@simonbogutzky/solving-localization-and-asset-issues-in-swift-packages-for-swiftui-views-2378686bdd9e</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=797fb56d9743" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Integrating SwiftUI Features into UIKit Projects: A Step-by-Step Guide]]></title>
            <link>https://medium.com/@simonbogutzky/integrating-swiftui-features-into-uikit-projects-a-step-by-step-guide-efc6f31b385d?source=rss-e85e115a0166------2</link>
            <guid isPermaLink="false">https://medium.com/p/efc6f31b385d</guid>
            <category><![CDATA[swiftui]]></category>
            <category><![CDATA[uikit]]></category>
            <dc:creator><![CDATA[Dr. Simon Bogutzky]]></dc:creator>
            <pubDate>Sun, 28 Apr 2024 13:01:28 GMT</pubDate>
            <atom:updated>2024-04-29T16:01:54.009Z</atom:updated>
            <content:encoded><![CDATA[<p>Are you eager to bring the power and simplicity of SwiftUI features into your existing UIKit projects? Look no further! This actionable guide provides a detailed walkthrough to seamlessly integrate SwiftUI features into your UIKit-based apps, promoting collaboration and innovation across your development team.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-vGhCVZz3KW7Ij1pb3n26w.jpeg" /></figure><h3>Understanding the Objective</h3><p>Suppose you’re enthusiastic about leveraging SwiftUI’s modern UI development paradigm within your legacy UIKit project. In that case, this guide will equip you with the knowledge and my technique to integrate SwiftUI features smoothly, enabling your UIKit colleagues to benefit from SwiftUI’s efficiency and flexibility.</p><h3>Integration Steps</h3><ul><li>Define Publisher Object: Create a publisher object class to manage states related to interaction events within the SwiftUI views. Utilize the @Published property wrapper to publish changes in the states. In my example, two states are defined for the posture feature (PosturePackage) that will be integrated into the HealthApp.</li></ul><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/fbabebd632a0b7d8cfdb0cc992509a72/href">https://medium.com/media/fbabebd632a0b7d8cfdb0cc992509a72/href</a></iframe><ul><li>Create SwiftUI Views: Develop SwiftUI views that encapsulate the desired features or UI elements to be integrated into the UIKit project. In the views, we inject the interaction events and trigger state changes when they happen (e.g., Button Actions).</li></ul><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/a2d0fe0894d9f922d1316fa4e281b826/href">https://medium.com/media/a2d0fe0894d9f922d1316fa4e281b826/href</a></iframe><ul><li>Implement Delegation for Communication: We define a delegate protocol for a UIViewController and methods to communicate state changes in our SwiftUI feature to the parent UIKit project, which is a well-known pattern in UIKit. Important: methods are marked with@MainActorand must be called only on the main thread for thread safety and UI responsiveness.</li></ul><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/a711d334c56ee16a8e164a24e0cf2f59/href">https://medium.com/media/a711d334c56ee16a8e164a24e0cf2f59/href</a></iframe><ul><li>Create UIKit UIViewController: Design a view controller as the entry point for integrating SwiftUI features into the UIKit project. Use UIHostingController to embed the SwiftUI views within the UIKit view hierarchy. The hosting controller is added as a child to the current view controller (self), and its view is added to the view hierarchy. Auto Layout constraints are applied to make the hosting controller&#39;s view match the edges of the parent view controller&#39;s view. The view resizes with the parent. For iOS 16.0 and later, sizingOptions are set to .intrinsicContentSize for self-sizing. For older versions, setNeedsUpdateConstraints is called to update the layout constraints.</li><li>Handle State Changes with Combine: Utilize Combine’s sink method to subscribe to changes in the observable object’s @Published property within the view controller. This allows seamless handling of state changes of interaction events. Upon these changes, trigger the delegate methods.</li></ul><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/57544ee6f80eb02bea24ae2ee854baef/href">https://medium.com/media/57544ee6f80eb02bea24ae2ee854baef/href</a></iframe><ul><li>Now, we have a simple UIViewController and its delegate protocol to integrate it programmatically into our UIKit view navigation flow. See the attached Git Project at the end of this guide.</li></ul><p>By following this actionable guide, you can effectively integrate SwiftUI features into your existing UIKit projects. This will unlock new UI development opportunities and foster collaboration within your development team.</p><p><a href="https://github.com/simonbogutzky/HealthApp">GitHub - simonbogutzky/HealthApp: This way of integration requires creating SwiftUI views, defining an observable object to manage the state, creating a UIKit UIViewController to embed the SwiftUI views, handling state changes with Combine, and implementing delegation for communication.</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=efc6f31b385d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Solving Localization and Asset Issues in Swift Packages for SwiftUI Views]]></title>
            <link>https://medium.com/@simonbogutzky/solving-localization-and-asset-issues-in-swift-packages-for-swiftui-views-2378686bdd9e?source=rss-e85e115a0166------2</link>
            <guid isPermaLink="false">https://medium.com/p/2378686bdd9e</guid>
            <category><![CDATA[swiftui]]></category>
            <category><![CDATA[swift-package]]></category>
            <dc:creator><![CDATA[Dr. Simon Bogutzky]]></dc:creator>
            <pubDate>Sun, 24 Mar 2024 13:02:32 GMT</pubDate>
            <atom:updated>2025-02-03T16:28:43.501Z</atom:updated>
            <content:encoded><![CDATA[<p>Are you encountering difficulties using localized strings and image assets from a Swift package in your SwiftUI views, especially when nested within another package? You’re not alone. Many developers face this challenge, but fear not! In this actionable guide, we’ll explore resolving these issues effectively, ensuring that your SwiftUI views display the correct localized text and images regardless of their location within your project’s structure.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/683/1*yn9xJC9JHJvYRGpOrkaFOQ.jpeg" /></figure><h3>Understand the Problem</h3><p>Before diving into solutions, let’s grasp the root of the issue. When using localized strings and image assets within a Swift package, SwiftUI views might not display them correctly, particularly when nested inside another package. The main issue concerns how resources are accessed during the runtime. By default, SwiftUI Text and Image rely on the main bundle to access resources, but when working with packages, we must ensure that the correct bundle is referenced.</p><h3>Choose the Right Bundle</h3><p>The solution depends on correctly specifying the bundle from which resources should be accessed. Leave the bundle parameter empty or set it to .main in standalone projects, and the main bundle will be accessed. However, when dealing with packages, you must decide whether the resources should be accessed within the parent project or the package itself. If you opt for the parent project, use an empty bundle parameter or .main. For package resources, declare their location in the package manifest or place them in the source folder. This prompts Xcode to generate the module bundle, enabling you to select .module for the bundle parameter.</p><h3>Implement the Solution</h3><p>Now that we understand the problem and how to choose the right bundle, it’s time to implement the solution in your SwiftUI views. An example scenario: our RocketApp uses a RocketView from the FeaturePackage.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/8d7d4d8b44fa5b3e07264521802fc627/href">https://medium.com/media/8d7d4d8b44fa5b3e07264521802fc627/href</a></iframe><p>This RocketView uses an ImageView to display an image and a localized caption to be retrieved from the FeaturePackage resources. But the ImageView is part of the ComponentPackage.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/cc3e33c0056f6881e210dcc351a72db6/href">https://medium.com/media/cc3e33c0056f6881e210dcc351a72db6/href</a></iframe><p>To ensure that the Text and Image in the ImageView know where to access resources during runtime, we add a bundle parameter and pass the value .module through ImageView.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/b14842fc5898693160ddbb9a51046aaa/href">https://medium.com/media/b14842fc5898693160ddbb9a51046aaa/href</a></iframe><p>By following these actionable steps, you can overcome localization and asset issues when using Swift packages with SwiftUI views. Understanding the problem, implementing the solution, and choosing the right bundle will ensure that your SwiftUI views display localized text and images correctly, regardless of their location within your project. Don’t be discouraged by these challenges when working with Swift packages. Instead, empower yourself with the knowledge to effectively resolve them and create more modular SwiftUI projects.</p><p><a href="https://github.com/simonbogutzky/RocketApp">GitHub - simonbogutzky/RocketApp: Choose the correct bundle to resolve localization and asset issues in SwiftUI views nested within Swift packages. ImageView in RocketView retrieves FeaturePackage resources by passing the .module bundle parameter.</a></p><p>Does your Swift package fail to display localized content correctly? <a href="https://medium.com/@simonbogutzky/ensuring-proper-localization-in-modular-swift-apps-797fb56d9743">https://medium.com/@simonbogutzky/ensuring-proper-localization-in-modular-swift-apps-797fb56d9743</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2378686bdd9e" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>