<?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 Evangelos Gkountouras on Medium]]></title>
        <description><![CDATA[Stories by Evangelos Gkountouras on Medium]]></description>
        <link>https://medium.com/@evangelos.gkountouras?source=rss-75f2659009bc------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*LC0GymzR2fM5DoK26gBJew.png</url>
            <title>Stories by Evangelos Gkountouras on Medium</title>
            <link>https://medium.com/@evangelos.gkountouras?source=rss-75f2659009bc------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 17:39:49 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@evangelos.gkountouras/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[We Didn’t Ask an AI to Build a Feature. We Gave It a Delivery Pipeline.]]></title>
            <link>https://medium.com/arconsis/we-didnt-ask-an-ai-to-build-a-feature-we-gave-it-a-delivery-pipeline-7d33bda824c5?source=rss-75f2659009bc------2</link>
            <guid isPermaLink="false">https://medium.com/p/7d33bda824c5</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Evangelos Gkountouras]]></dc:creator>
            <pubDate>Mon, 15 Jun 2026 07:29:04 GMT</pubDate>
            <atom:updated>2026-06-25T10:53:38.235Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6TJBJPtrunKKVbpAB0qwEA.jpeg" /></figure><p><em>Part 2: A Real Feature, End to End: the Trending Badge.</em></p><p>In <a href="https://medium.com/arconsis/we-didnt-ask-an-ai-to-build-a-feature-we-gave-it-a-delivery-pipeline-4293c59b7a0f"><strong>Part 1</strong></a>, we described the Agent Orchestration Framework we built for arconsis Eats: the agents, the lifecycle, the file-based state, and the safety rails. Here we let it run. The feature is a Trending Badge on restaurant feed cards. The pipeline is the same one we just described. Everything below is what actually happened.</p><h3>A Real-Life Example: The Trending Badge</h3><p>The feature itself is simple to describe: a &quot;Trending&quot; pill appears on a restaurant&#39;s feed card when it has seen a burst of recent review activity. The user-facing surface is small. The cross-module work is not.</p><h3>How the architect planned it</h3><p>The architect produced plan.md, 153 lines of file paths, function signatures, and acceptance criteria, along with the corresponding state.json. There were no open questions: the product decisions were all resolvable by sensible defaults. A 7-day window, a 3-review threshold, both tunable via application.properties:</p><pre>eats.trending.window-days=7<br>eats.trending.min-reviews=3</pre><p>The slice graph it came up with had six steps, each depending on the one before:</p><ul><li><strong>backend-domain</strong>: backend-author implements the server-side trending logic</li><li><strong>backend-tests</strong>: qa-tester adds test coverage for the new backend behavior</li><li><strong>shared-contracts</strong>: kmp-shared-author updates the shared DTO layer</li><li><strong>api-client-data</strong>: api-client-author propagates the field through the client cache and repository</li><li><strong>frontend-ui</strong>: frontend-author renders the badge in the Compose UI</li><li><strong>final-integration</strong>: code-reviewer reviews the full branch as one integrated system</li></ul><p>Two things stood out in the plan.</p><p>First, <strong>no migration</strong>. The architect figured out the trending flag is derivable from the existing reviews table through a GROUP BY place_id HAVING count(*) &gt;= :minReviews query scoped to the window. The plan explicitly forbids creating a new migration file. If a reviewer sees one, that&#39;s a defect.</p><p>Second, it flagged a <strong>cross-caller risk</strong> ahead of time. The trending flag would be computed in the home feed, but the profile screen renders the same reviews through a different code path. If that second path wasn’t updated, the same restaurant could show as “Trending” on the feed and not trending on your profile, for the exact same review data. The architect explicitly noted this in the reviewer instructions before any code existed. That’s the kind of seam that’s invisible when you’re reviewing one slice at a time.</p><p>The plan reviewer caught an issue on the first pass. The command ./gradlew :shared:compileKotlinMetadata is a SKIPPED no-op task on this project. The architect re-ran, swapped it for :shared:compileCommonMainKotlinMetadata, and the second pass got APPROVE_PLAN.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Bp5wyQVzg5tf3g4QAaMY0A.png" /><figcaption><em>The architect’s plan approved — one human decision away from writing code</em></figcaption></figure><h3>What each agent committed</h3><p>The branch history tells the story. Each agent’s work is one or two commits: a feat: commit with the production change, and a chore(infra): checkpoint that records the slice&#39;s state transition. 13 commits total, every slice checkpointed, every verdict preserved.</p><pre>695c6aa chore(infra): complete frontend-ui layer for trending-badge<br>fff2b69 feat(frontend): add trending badge to home feed cards<br>7a7fadf chore(infra): complete api-client-data layer for trending-badge<br>e049c5c feat(api-client): propagate isTrending through client cache layer<br>36f1305 chore(infra): complete shared-contracts layer for trending-badge<br>a003958 feat(kmp-shared): add isTrending field to ReviewResponse DTO<br>d80ba57 chore(infra): complete test layer for trending-badge backend<br>33bdd57 chore(deps): move MockK to version catalog and record review state<br>c0efe61 test(server): fix reviewer-rejected test issues for trending-badge<br>f8b0d40 fixup(server): replace @QuarkusTest with pure MockK unit tests<br>c0dc778 test(server): add trending-badge test coverage for FeedService<br>1e82dfb chore(state): update trending-badge progress for backend-author<br>c578d7d feat(server): add trending badge flag to feed responses</pre><p>A quick note on those commit messages. Every one follows the commit-messages skill we built: conventional-commit prefixes, subject under 72 characters, body that explains <em>why</em>, plus Slice: and Agent: footers. This isn&#39;t cosmetic. Six months from now, when someone runs git blame on ReviewResponse.isTrending, the commit message will explain the backward-compatibility reasoning.</p><h3>🔴 backend-author</h3><p>The first slice extended the backend API to support trending places. The agent added a query to identify places with a spike in recent review activity, wired the result into the feed response, and made sure the trending flag flowed through every path that returns review data to a client. No migration needed; the data was already there. Server compiles clean.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yjSZbzma39tEfe6BzIky-g.png" /><figcaption>The backend-author picks up its slice — state transitions from PENDING to IN_PROGRESS</figcaption></figure><h3>🟡 qa-tester and the retry loop that earned its keep</h3><p>This is the slice where the framework proved its value.</p><p><strong>Attempt 1.</strong> The qa-tester wrote integration tests per the plan, but hit an environment issue: Docker wasn’t running, so the database-backed test setup couldn’t start. Fair enough. The agent pivoted to unit tests with a mocking library, but introduced two problems in doing so: it added the new test dependency by hardcoding a version directly in the build script, bypassing the project’s pinned dependency catalog, and it quietly dropped the test that was supposed to verify feed/profile parity, the exact cross-layer seam the architect had flagged as the highest-risk integration point.</p><p>The code-reviewer rejected it. Both findings were BLOCKING.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XAUZ76yhA3JnTCHmhx4pEQ.png" /><figcaption>The reviewer rejects the QA slice — Request Changes</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dL0JDKJ3zge5KXEUnOWkwQ.png" /><figcaption>Inside the review md file for the QA tester — two blocking findings</figcaption></figure><p><strong>Attempt 2.</strong> The agent fixed both: the dependency was moved into the version catalog where it belonged, and the missing parity test was written properly, covering the scenario where the same restaurant shows up on both the home feed and a user’s profile, and verifying they agree on its trending status. 21 tests, 0 failures. Re-review → APPROVE.</p><blockquote><em>The honest take: the agent got it wrong the first time, and that’s fine. The framework caught it. The findings were specific enough to fix without a human round-trip. The retry cost about $3 on top of the original $2.37, versus a human catching it in PR review three days later, or worse, it landing on main and silently degrading coverage.</em></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*K62bl-Yf5KlevSzeVACyzQ.png" /><figcaption>Retry approved — both blocking issues resolved, critical seam coverage restored</figcaption></figure><h3>🟦 kmp-shared-author</h3><p>The smallest slice in the branch was a single new field added to the shared DTO that both server and clients rely on. The code was trivial. The reasoning in the commit message was the point: the field needed a default value not for convenience, but for backward compatibility. Older installed app builds receiving a payload that doesn’t yet include the field must not crash. They should just silently treat the place as non-trending. The agent got this right and explained why in the commit, which matters more than it sounds six<br>months from now when someone wonders if the default is safe to remove.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YB58BiPHY4KEHWqLY3M2Ww.png" /><figcaption><em>The kmp-shared-author completes its slice — 15 tool uses, one new DTO field</em></figcaption></figure><h3>🟢 api-client-author</h3><p>The client slice threaded the trending flag through the offline cache layer and up to the repository that the UI reads from. The key concern here was the same backward-compatibility one: the cached data model also needed a default so that older locally-stored payloads wouldn’t break on app update. No new infrastructure, no new dependencies. Just making sure the new field traveled all the way from the network response to the UI without getting dropped.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RV4k8jtUuHja3XYohGN22A.png" /><figcaption>The api-client-author propagates the flag through the cache layer — build passes, slice CHECKED</figcaption></figure><h3>🟠 frontend-author</h3><p>The final slice rendered the badge in the Compose UI. The agent overlaid a “Trending” pill on the place photo in the feed card, and handled accessibility correctly. The badge is announced as a single unit by screen readers rather than reading the icon and label separately.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*e7C5zFV3TQNplHtEQNSbLw.png" /><figcaption>The frontend-author commits the Trending Badge to the home feed</figcaption></figure><p>One deliberate choice: the trending field was added to the UI model <strong>without</strong> a default value, which forces the compiler to catch any mapping function that forgets to pass it through. Defaults are convenient; their absence is a contract.</p><h3>What the final integration review caught</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*niCqz0D12mXJyKjKb3oVWg.png" /><figcaption>Final integration review — the full branch reviewed as one system before the CI gate</figcaption></figure><p>The code-reviewer’s review.md ran the whole branch against origin/develop. Verdict: <strong>APPROVE</strong>, no critical or major issues. Six nits, three worth mentioning.</p><p>It caught a minor issue where a service function was accepting a parameter it never actually used. Small thing, but it creates real cognitive overhead: anyone reading that code later would naturally assume the function’s behavior depends on what you pass in, when it doesn’t.</p><p>There’s no empty-feed short-circuit. A user with zero reviews still triggers a JPQL round-trip to compute trending places. One-line fix, but the kind of thing that adds up at scale.</p><p>And the finding that points back at usω: the MockK catalog edit straddles the automation boundary. The framework handled it eventually, but the architect should have anticipated the missing test dependency in the first place. That’s a prompt update for next time, not a framework limitation.</p><h3>The numbers</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gBYSOugAyKjaJi0V4iyu8A.png" /><figcaption>Cost Report</figcaption></figure><p>The full feature, from /feature trending-badge to integration-review approval:</p><p>Wall time was about 4.5 hours, of which maybe 30 minutes required a human present. Total tokens: 24.2 million (22M cache-read, 2M cache-write, 192k output). Total cost: <strong>$22.33</strong>, roughly $13.50 on Opus for the architect and reviewer, $8.83 on Sonnet for the authors and tester. There were 5 retries across the whole pipeline (the plan got revised twice, the backend-tests slice took three attempts). The feature touched 10 production files and added 3 test files.</p><p>The retries move the cost. A first-pass slice runs $0.30–$0.70. A reviewer rejection adds $1.50–$2.00. The MockK round-trip alone (plan-review retry, qa-tester retry, re-review) was about $7 of the $22.</p><p>We’d take that trade. The alternative, a human catching the catalog-edit issue in PR review three days later, isn’t free either.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2AzNME3F9PNq7bxLd_VOqQ.png" /><figcaption>Cost breakdown per agent</figcaption></figure><h3>What the framework still doesn’t do</h3><p>iOS-native code is out of scope. Swift, SwiftUI, signing, provisioning: the architect emits OPEN QUESTION: and stops. Platform-specific Compose (androidMain / iosMain / jvmMain), like cameras, file pickers, push notifications, anything needing expect/actual, is a human job. Gradle and version-catalog edits straddle the boundary, as the MockK incident demonstrated. CI/CD workflow edits are out of scope entirely.</p><p>And the agents still make mistakes. The qa-tester missed the cross-caller test. The reviewer missed the unused computeTrendingFlags parameter on the first per-slice pass and only caught it in the final integration review. The framework&#39;s value is <em>catching</em> mistakes through layered review, not <em>preventing</em> all of them.</p><p>The framing we keep coming back to: <strong>this is a delivery pipeline, not an autonomous engineer.</strong> The pipeline does planning, sequencing, writing, verifying, reviewing, checkpointing. The human does the judgement calls: approving the plan, adjudicating two-strikes rejections, pushing the branch, opening the PR. That’s a much smaller surface than “build me a feature,” and a much bigger lever than “autocomplete my next function.”</p><p>What we got out of this wasn’t a snippet or a half-built prototype. It was a working feature across every layer of a real Kotlin Multiplatform system: backend logic, shared contracts, client integration, and the UI. Think of it as a marathon. The pipeline carries you through the first 41 kilometers: design, implementation, and the cross-module coordination that usually eats the most time. The last kilometer is still yours. You review with fresh eyes, fix the edge cases, fight over naming, and decide whether the result clears the bar you’d actually ship against. The framework doesn’t remove that work. It makes sure that’s the only work left.</p><p>The trending badge took five slices, one retry loop, about five hours of mostly-unattended runtime, and $22 of API cost. The branch was green on /verify the first time we ran it. The next morning we opened the PR.</p><p>We didn’t ask an AI to build it. We gave it a pipeline.</p><p>Stay tuned!!</p><p>Special thanks to my colleague <a href="https://medium.com/@akoufa">Alex Koufatzis</a> for co-authoring this series.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7d33bda824c5" width="1" height="1" alt=""><hr><p><a href="https://medium.com/arconsis/we-didnt-ask-an-ai-to-build-a-feature-we-gave-it-a-delivery-pipeline-7d33bda824c5">We Didn’t Ask an AI to Build a Feature. We Gave It a Delivery Pipeline.</a> was originally published in <a href="https://medium.com/arconsis">arconsis</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[We Didn’t Ask an AI to Build a Feature. We Gave It a Delivery Pipeline.]]></title>
            <link>https://medium.com/arconsis/we-didnt-ask-an-ai-to-build-a-feature-we-gave-it-a-delivery-pipeline-4293c59b7a0f?source=rss-75f2659009bc------2</link>
            <guid isPermaLink="false">https://medium.com/p/4293c59b7a0f</guid>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Evangelos Gkountouras]]></dc:creator>
            <pubDate>Fri, 12 Jun 2026 07:01:03 GMT</pubDate>
            <atom:updated>2026-06-23T12:16:54.139Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6TJBJPtrunKKVbpAB0qwEA.jpeg" /></figure><p><em>Part 1: The Framework: seven AI agents, file-based state, and one human gate.</em></p><p>At <a href="https://www.arconsis.com/">arconsis</a>, we spend a lot of time thinking about the tools, frameworks, and practices that shape how software actually gets built, across very different customer contexts: e-commerce, automotive, finance, healthcare. The question we keep coming back to, regardless of the stack, is always the same: <em>what does it take to deliver software that is reliable, maintainable, and honest about its trade-offs?</em></p><p>AI-assisted development is the latest thing forcing that question into the open. And honestly, we’re not interested in it for the novelty. “An LLM wrote a function” stopped being interesting around the time autocomplete grew a brain. The real question, the one our customers will eventually ask us about, is whether AI agents can meaningfully contribute to a <strong>real production codebase</strong>. One with multiple modules, strict migration discipline, cross-platform targets, conventions that took years to settle, and a definition of “done” that includes things like backward compatibility for already-installed builds. That’s a very different problem from generating a snippet.</p><p>So this article isn’t a model benchmark or a tool comparison. It’s about <strong>process</strong>: how we structured agent collaboration so that the output is reviewable, auditable, and recognisable as code our team would have written by hand. To make any of that concrete, we did the obvious thing: we built the framework against one of our own Kotlin Multiplatform projects and let it ship a real feature end to end. Everything below comes from that exercise.</p><h3>The arconsis eats App</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/161/1*yl150dnobmNyeZSLA7BY6w.jpeg" /></figure><p>is one of our internal apps, a restaurant-discovery product we also use as a sandbox for tooling questions like this one. The shape of the codebase is what makes it useful for the experiment, not the product itself.</p><p>It’s a Kotlin Multiplatform monorepo with three layers. server/ is a Quarkus backend with a Flyway-managed database. Migrations are forward-only, no exceptions. shared/ is a module with the serializable DTOs that both server and clients use. composeApp/ is a Compose Multiplatform UI targeting Android, iOS, and Desktop, with an offline cache layer in between.</p><p>Those three layers have a strict dependency order: server → shared → client → UI. A single feature can require changes at every level, and each layer has to be correct before the next one can build against it.</p><p>This is exactly the kind of codebase where unsupervised AI coding (vibe-coding) falls apart. <br>If a client-side field name drifts from what the server actually emits, nothing fails at build time. The server emits isTrending, the client deserializes is_trending, everything compiles green. You find out in production.</p><blockquote><em>A model allowed to “just keep coding” through a stack like this leaves you with a green build and a broken product. The question isn’t “can it write Kotlin?” </em>It’s whether it can ship a feature without you watching every keystroke.</blockquote><h3>The Agent Orchestration Framework</h3><h3>A pipeline, not a prompt</h3><p>We didn’t build an AI that writes features. We built a <strong>delivery pipeline</strong> that uses AI agents as a team:</p><blockquote>architect → author → verify → review → fix → checkpoint → integrate → CI gate.</blockquote><p>Each step has a defined input, a defined output, a verification command, and a place to write its findings. None of the steps are “an LLM decides what to do next.” Routing is a deterministic Markdown state machine. LLMs do the work. They never decide <em>what</em> work happens.</p><h3>The agents</h3><p>The roster lives in .claude/agents/. Each agent is one Markdown file with a role description, allowed tools, and the prompt the model loads when invoked.</p><p>The 🔵 <strong>architect</strong> (Opus) reads the codebase and produces the plan and the slice graph. It understands the system, decides what needs to change, and never touches production code.<br>The 🔴 <strong>backend-author</strong> (Sonnet) owns the server layer: database schema, business logic, and API endpoints.<br>The 🟡 <strong>qa-tester</strong> (Sonnet) writes unit and integration tests.<br>The 🟦 <strong>kmp-shared-author</strong> (Sonnet) owns the client-server contract, making sure field names match the server JSON exactly.<br>The 🟢 <strong>api-client-author</strong> (Sonnet) takes those contracts and wires them through the client data layer: network calls, local cache, and the repository the UI reads from.<br>The 🟠 <strong>frontend-author</strong> (Sonnet) builds the screens and view logic that the user actually sees.<br>And the 🟣 <strong>code-reviewer</strong> (Opus) reviews the plan, every per-slice diff, and the final integration diff, but never writes a line of code.</p><p>The Opus/Sonnet split is deliberate. Opus does <em>judgement</em>: planning and reviewing. Sonnet does <em>throughput</em>: writing code against a clear spec. The cost breakdown below shows it paying off: about 60% of the spend goes to Opus on the architect and reviewer, 40% to Sonnet on the actual code.</p><h3>The lifecycle of a feature</h3><p>One command starts the whole thing:</p><pre>/feature trending-badge &quot;Show a Trending badge on feed cards for popular places&quot;</pre><p>That looks like a prompt.</p><p>It isn’t.</p><figure><img alt="Inside the feature command" src="https://cdn-images-1.medium.com/max/1024/1*6PZlKie-eBG6GYvJKPCKGA.png" /><figcaption>Inside the /feature command</figcaption></figure><p>In our framework, /feature is not a request for an LLM to “go build something.” It is the entry point into a deterministic delivery pipeline. The command validates the repository state, creates the feature branch, and immediately kicks off the first three steps of the workflow: the architect reads the codebase and produces the plan, the reviewer sanity-checks that plan before a single line of code is written, and then the pipeline pauses for human approval. Only after that gate does implementation begin, dispatching the right author agents in dependency order, enforcing verification at every slice, recording checkpoints, and finishing with a full integration review.</p><p>The important part isn’t that an AI writes code. It’s that the AI operates inside a workflow that looks much closer to CI/CD than chat.</p><p>Here’s what happens, end to end.</p><p><strong>Start clean.</strong> Before any model is invoked, the framework checks the basics: clean working tree, branch cut from develop, no uncommitted changes for an agent to accidentally overwrite. If any of that isn&#39;t true, the workflow stops. A surprising amount of &quot;AI went off the rails&quot; behavior starts with an ambiguous workspace. We decided the framework should remove that ambiguity rather than ask an agent to reason about it.</p><p><strong>The architect plans, but never codes.</strong> The first agent reads the codebase and decides what needs to happen: which layers, which files, whether a migration is actually necessary, where the integration risks are. It produces two files: plan.md (human-readable blueprint with file paths, strategy, acceptance criteria, and reviewer notes) and state.json (machine-readable slice graph with dependency edges, owning agents, verification commands, retry state, and completion status). That second file is what makes the whole pipeline resumable. If the session dies midway, /implement trending-badge reads state.json, finds the first incomplete slice, and picks up from there. No reconstructing state from conversation history.</p><p><strong>The plan is reviewed before any code exists.</strong> The code-reviewer checks whether the workflow is actually executable: slices in the right order, file paths plausible, verification commands valid, migration rules respected, integration risks visible. Findings land in reviews/00-plan.review.md. For Trending Badge, the reviewer caught a real problem before a single line was written. The architect had selected a Gradle task that was a skipped no-op on this project. The plan was revised and corrected before implementation was allowed to proceed. The reviewer wasn&#39;t checking code quality. It was checking whether the pipeline itself was safe to run.</p><p><strong>One human gate, before coding starts.</strong> After the reviewer approves, the pipeline pauses. You read the architecture, check the slice decomposition, answer any OPEN QUESTION: markers the architect couldn&#39;t safely resolve. This is the last mandatory stop before multiple agents start changing a multi-module codebase. Once you approve, the state machine takes over.</p><p><strong>The state-machine loop.</strong> One slice at a time, in dependency order. Each slice has one owner, one scope, one verification command, and one review step. Backend compiles before shared contracts are touched. Shared DTOs compile before client code depends on them. Client propagation works before the UI renders the new field. The verification command isn’t improvised by the agent. It’s in the plan, stored in state.json. After verification, the reviewer inspects only the current slice diff ($pre_sha..HEAD), keeping findings focused. One retry on rejection; two rejections surfaces the issue to you. No unbounded autonomous repair loops.</p><p><strong>Final integration review, then </strong><strong>/verify.</strong> Once all slices are done, the reviewer sees the whole branch against origin/develop, checking the seams that per-slice review can&#39;t see: does the server emit the field the client expects, do DTO defaults preserve backward compatibility, is anything locally correct but globally wrong? After that comes the CI gate: five Gradle tasks, all must pass. No auto-fixing at this stage. Auto-fix at the final gate is how you ship something that&#39;s technically green but no longer the thing that was reviewed. /verify passing is the only definition of done.</p><h3>The key design decision: agents communicate through files</h3><p>Most multi-agent systems try to pass context through conversation history. That’s expensive, unbounded, and impossible to audit after the fact. We went the other direction entirely: <strong>agents don’t share conversation history. At all.</strong> Every agent communicates through files on disk.</p><p>plan.md says what to build. state.json tracks where we are in the build. progress.md records what&#39;s been done. reviews/&lt;agent&gt;.md contains what the reviewer found for each slice. review.md holds the final integration review. One agent writes, the next one reads. The orchestrator never asks an agent &quot;what did you do?&quot; It reads progress.md. The reviewer never asks an author &quot;why?&quot; It reads the diff.</p><p>Three things fall out of this almost for free.</p><p><strong>Auditability.</strong> Every decision is a file sitting in git history. No black box. You can reconstruct any feature’s entire AI-assisted development story from the files on the branch.</p><p><strong>Resumability.</strong> If your laptop dies mid-feature, /implement trending-badge reads state.json, finds the first not-done slice, and picks up exactly where it left off. It&#39;s a query against a file, not a vibe check.</p><p><strong>Clean separation of state from model memory.</strong> The framework’s state is the file tree. The model’s memory is a single agent’s invocation context. These are different things and they should live in different places.</p><h3>Safety rails (the parts that can’t be talked out of)</h3><p>LLM agents are remarkably good at finding the direct path to “this looks done.” Some of that creativity is how you end up editing a released Flyway migration. For the non-negotiables we use <strong>harness-level hooks</strong>, not prompts you can talk your way around. They live in scripts/claude/ and are wired in .claude/settings.json.</p><p>guard-migrations.sh is the most critical one. It fires on every file edit or write. If the target is a Flyway migration that already exists on origin/main or origin/develop, the hook blocks it outright. There&#39;s an escape hatch (ALLOW_MIGRATION_EDIT=1), but a human has to set it. No agent can flip it on its own. The second hook, record-subagent-cost.sh, fires on every subagent exit, reads the transcript, aggregates token usage, prices it, and appends one line to costs.jsonl. That&#39;s how we got the cost breakdown later in this article.</p><p>These hooks run <strong>automatically and outside the agents’ control.</strong> They can’t be argued with, prompt-engineered around, or skipped.</p><p>The rest of the safety surface lives in settings.json and the state machine itself. On the permissions side: git push, git reset, git rebase, gh pr create, and gh pr merge all require explicit human approval. Gradle compile/test, read-only git, and read-only gh are auto-allowed. The bottom line: <strong>no agent can push or open a PR.</strong> The branch is yours to inspect first.</p><p>On the process side: a plan-level human gate means no code gets written until you’ve read and approved the architecture. A 1-retry cap per review finding prevents infinite fix loops. Two rejections and it’s surfaced to you. Per-slice diffs are scoped so the reviewer only sees $pre_sha..HEAD for the current slice, not the entire branch. And a BLOCKED: signal lets agents flag problems instead of silently skipping them. The qa-tester used this twice on the worked example below.</p><h3>Things we deliberately left out</h3><p>No parallel agents: the dependency graph (server → shared → client → UI) is sequential by nature, and trying to parallelize it buys you deserialization crashes. No meta-planner: an LLM picking which agent runs next would make the whole system non-reproducible, and frankly we don’t trust that. No shared memory across agents. Each one gets the plan, its task, and the artifacts. Nothing else. Boring is reliable.</p><p>That’s the framework. In <a href="https://medium.com/p/7d33bda824c5">Part 2</a>, we put it to work on a real feature: a Trending Badge that spans every layer of the stack, from backend query to Compose UI. We walk through what each agent did, where the retry loop earned its keep, and what the whole thing actually cost.</p><p>Stay tuned!!</p><p>Special thanks to my colleague <a href="https://medium.com/@akoufa">Alex Koufatzis</a> for co-authoring this series.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4293c59b7a0f" width="1" height="1" alt=""><hr><p><a href="https://medium.com/arconsis/we-didnt-ask-an-ai-to-build-a-feature-we-gave-it-a-delivery-pipeline-4293c59b7a0f">We Didn’t Ask an AI to Build a Feature. We Gave It a Delivery Pipeline.</a> was originally published in <a href="https://medium.com/arconsis">arconsis</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Spring Boot vs Quarkus Part 2 (JVM Runtime Performance)]]></title>
            <link>https://medium.com/arconsis/spring-boot-vs-quarkus-part-2-jvm-runtime-performance-af45d0db116e?source=rss-75f2659009bc------2</link>
            <guid isPermaLink="false">https://medium.com/p/af45d0db116e</guid>
            <category><![CDATA[spring-boot]]></category>
            <category><![CDATA[quarkus]]></category>
            <category><![CDATA[jvm-architecture]]></category>
            <category><![CDATA[spring]]></category>
            <category><![CDATA[jvm]]></category>
            <dc:creator><![CDATA[Evangelos Gkountouras]]></dc:creator>
            <pubDate>Mon, 30 Jan 2023 10:10:40 GMT</pubDate>
            <atom:updated>2023-02-03T16:36:26.571Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UNuQ798XGUUBNz-17phiMQ.png" /></figure><h4>Intro</h4><p>At <a href="https://www.arconsis.com/">arconsis</a>, we are always interested in comparing the frameworks and tools we use for various projects and customers in different fields such as e-commerce, automotive, and finance. We are not only driven by the fun of benchmarking frameworks but also concerned about the performance, resource savings, and cost factor of the specific technologies.</p><p>Therefore, this article is focused on analyzing the runtime performance of <a href="https://spring.io/projects/spring-boot">Spring Boot</a> and <a href="https://quarkus.io/">Quarkus</a> in a real-world scenario, deployed in a cloud native environment on AWS Elastic Container Service, instead of in a sterialized laboratory environment. Following that approach, we aim, as far as possible, to match the production workloads of our customers.</p><p>If you first want to get a comprehensive overview comparing Spring Boot with Quarkus and what features they offer, have a look at the <a href="https://medium.com/arconsis/spring-boot-vs-quarkus-6f44421b7213">first part</a> of this article series.</p><h4><strong><em>Benchmark Setup</em></strong></h4><p>For the benchmark itself, we created a simple Book Store Service, both in Spring Boot and Quarkus. This service exposes some REST endpoints for trivial CRUD operations.</p><p>For example we have defined the endpoint HTTP GET /books?limit=100 which returns the first 100 books from the Postgres DB.<br>The JSON response for a single book would look like the following:</p><pre>{<br>    &quot;id&quot;: &quot;876f1ca5–5149–456f-8ae0–6de1261c7e06&quot;,<br>    &quot;title&quot;: &quot;Hobbit&quot;,<br>    &quot;author&quot;: &quot;J. R. R. Tolkien&quot;,<br>    &quot;publisher&quot;: &quot;George Allen &amp; Unwin&quot;,<br>    &quot;releaseDate&quot;: &quot;1937–09–21&quot;<br>}</pre><p>Regarding the read operation from the Database, we kept it simple, defining a single SELECT query without any joins or more complex stuff.</p><p>Concerning the setup and architecture of the services we choose to use the reactive approach in both Spring Boot and Quarkus using <a href="https://docs.spring.io/spring-framework/docs/current/reference/html/web-reactive.html">Webflux</a> and <a href="https://quarkus.io/guides/resteasy-reactive">RESTEasy Reactive</a> respectively. We used neither Project Reactor nor Mutiny, but relied instead on Kotlin Coroutines, to write asynchronous code that looks and feels more the way plain normal sync code is written.</p><p>In our benchmark, we have tested the following versions of the frameworks:</p><p><em>Quarkus:</em></p><p>Quarkus 2.12, Kotlin 1.7.22, RestEasy Reactive, Hibernate Panache Reactive and Reactive PG Client</p><p><em>Spring Boot:</em></p><p>Spring Boot 3.0.2, Kotlin 1.7.22, Webflux, Spring Data R2DBC and PostgreSQL</p><p>The Dockerfile for both is based on the Red Had Universal Base Image OpenJdk (ubi9/openjdk-17-runtime) using the run-java.sh script for auto selecting optimised JVM settings for container runtimes.<br>You can find the code for the benchmarks <a href="https://github.com/arconsis/server_benchmarks">here</a>.</p><h4><strong><em>First benchmarking Observations:</em></strong></h4><p>For the eager readers, who are really impatient to know the results, the first observation we could quickly make is that Spring Boot, would not handle the load testing, when running on ECS Fargate with the following resource requirements: 1 vCPU and 2 GB of RAM.<br>The HTTP requests to the Spring Boot service would exceed our timeout<br>setting of 10 seconds and thus considered as failed. Hence, the error threshold of 50% failed requests would be quickly reached and our test would abort.</p><p>In comparison, Quarkus could handle the same load and perform actually very well using these constrained settings. This is an astonishing first observation, which talks about the very good job the Quarkus team has done optimizing it. So the slogan “Supersonic Subatomic Java” definitely proves to be true. In the end, being able to handle the same workload, using half of the resources in the cloud, provides a lot of cost savings for companies. In our opinion, this should be a significant factor for companies when checking out different technologies.</p><p>For Spring Boot to handle the same load test, we had to update the <a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definitions.html">Task Definitions</a> and vertically scale the Spring Boot service to 2 vCPU and 4 GB of RAM.</p><p>Although, we are looking forward to seeing if the results improve, when the AOT optimisations in Spring Boot 3, will be enabled for the JVM mode.</p><p>Another observation we could make is that both frameworks needed a warm up period. The performance of both frameworks would improve, in Spring Boot’s case even dramatically, after the initial load test round.</p><p>That said, let’s deep dive into the actual load test setup.</p><h4><strong><em>Test setup</em></strong></h4><p>For benchmarking, we used the <a href="https://loader.io/">loader.io</a> service. We defined the following load test:</p><p>HTTP Get Books endpoint with a limit of 100 books.</p><p>We did configure the test to use a maximum of 1000 clients over a period of 5 minutes. For more information regarding the test type checkout the loader.io <a href="https://support.loader.io/article/16-test-types#maintain-load">docs</a>.</p><p>For each test to run successfully and not be aborted, we defined a threshold of max 50% failed requests. This means that if the ratio of failed requests to the total count of requests would pass the 50% limit, the load test would be aborted. In addition to non 2XX requests also requests with a duration of more than 10 secs would be considered as timed out and of course count towards the aborting threshold.</p><h4><strong><em>Detailed Observations:</em></strong></h4><p>Let’s now dive into some more details.<br>We conducted our tests in two different resource configurations.</p><p><em>Resource configurations</em>: <br>- Case 1: 2vCPU and 4 GB of RAM<br>- Case 2: 3 instances per service with 1vCPU and 2 GB of RAM</p><ul><li><strong>Case 1 – 2CPU, 4GB:</strong></li></ul><p>In the first test case, we decided to measure the performance of the frameworks stressing them under load by maintaining 1000 clients who were firing as many requests as they could manage, for up to 5 minutes.</p><p>As expected both frameworks did manage to handle the pressure and respond to all requests successfully, albeit Quarkus excelling much more by responding in an average of 294 ms, in comparison with Spring Boot’s average response time of 1901 ms. Having much faster response times, unsurprisingly led to Quarkus processing way more requests than Spring Boot, 1,012,338 requests vs 156,953. So in the end Quarkus managed an impressive 3374rps compared to only 523rps by Spring Boot.</p><p><strong>Quarkus (response time)</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/924/1*wIoGRM88eXxlYjCnOw9XfQ.png" /></figure><p><strong>Spring Boot(response time)</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/930/1*kKZehBBBLRz1cv6T1HjLvQ.png" /></figure><p>Regarding CPU utilization, both Quarkus and Spring Boot, maxing it’s CPU usage at around 75%.</p><p><strong>Quarkus(CPU utilization)</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/309/1*VCaURmM_LguXo3MLdy2jIQ.png" /></figure><p><strong>Spring Boot(CPU utilization)</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/309/1*leYUHeDpfiLRUSAALZwwog.png" /></figure><p>Regarding Memory utilization, we did not observe any significant memory consumption by any of the two services. Both Quarkus and Spring Boot used very little of the available 4GB of memory (around 20–30%) and had pretty much similar memory requirements. This result was of course also not shocking as the 4GB should nowadays be a very high setting for most frameworks and workloads.</p><ul><li><strong>Case 2 – 3 instances 1CPU, 2GB:</strong></li></ul><p>For the second case we tried to use a more, close to real life, configuration with multiple instances per service, to match configurations we see in the projects of our clients.<strong><br></strong>In that case,<strong> </strong>we observed that both frameworks did manage to handle the pressure like before but again Quarkus surpassed SpringBoot, both on average response time and CPU utilization with 177 ms and around 77% respectively.</p><p><strong>Quarkus (<em>R</em>esponse time &amp; CPU utilization)</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/920/1*z1ulcjvMTKXTDL6Im3WtbQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/306/1*cTVyp7YrbHIeIPz75FBl1g.png" /></figure><p>On the contrary, Spring Boot managed it with 1852 ms of average response time and around 63% average CPU utilization. In this test case with the lower resource configuration per instance we also observed some errors when load testing Spring Boot which we analyzed and there seem to be some resource leak <a href="https://github.com/pgjdbc/r2dbc-postgresql/issues/580">issue</a> in the R2DBC Postgres Driver.</p><p><strong>Spring Boot (<em>R</em>esponse time &amp; CPU utilization)</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/932/1*q4wQWWykM_YwWDIMm0kRaA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/304/1*DV-Au8QM0dXLByhRzq2oIw.png" /></figure><p>In this test case too, the memory utilization was not an obstacle for both frameworks.</p><h4><strong>Conclusion</strong></h4><p>Despite the results, which indicate Quarkus is more optimized and suitable for Cloud Native workloads and can save us a lot of money, we should not forget the maturity and popularity of the Spring Boot framework.<br>This means that we cannot easily express a suggestion to use one framework over the other. <br>Most of the time, of course, choosing a framework requires a more complex analysis and procedure.<br>Specifically speaking about Spring Boot and Quarkus, on the one hand we can expect from Spring Boot more mature documentation and support and a higher popularity which could prove itself beneficial when staffing for a project.<br>On the other hand, Quarkus could run more efficiently and perform better by saving us costs and is also based on JEE and Microprofile Standards. In the end both frameworks do catching up in the areas they lag behind each other and the competition will provide only benefits for the developer community.</p><p>Stay tuned as in the next article in the series we will be comparing Spring Boot and Quarkus using native executables with GraalVM.</p><p>Last but not least, special thanks to my colleague <a href="https://medium.com/@akoufa">Alex Koufatzis</a> for co-authoring this article.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=af45d0db116e" width="1" height="1" alt=""><hr><p><a href="https://medium.com/arconsis/spring-boot-vs-quarkus-part-2-jvm-runtime-performance-af45d0db116e">Spring Boot vs Quarkus Part 2 (JVM Runtime Performance)</a> was originally published in <a href="https://medium.com/arconsis">arconsis</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>