<?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 Artem Zasypalov on Medium]]></title>
        <description><![CDATA[Stories by Artem Zasypalov on Medium]]></description>
        <link>https://medium.com/@a.zasypalov?source=rss-c7cbecad47de------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*K1_wStudqdwiHC1sNIvE3w.jpeg</url>
            <title>Stories by Artem Zasypalov on Medium</title>
            <link>https://medium.com/@a.zasypalov?source=rss-c7cbecad47de------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 05:00:52 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@a.zasypalov/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[Automating feature-flag cleanup at Yazio: from a prompt to CI]]></title>
            <link>https://medium.com/yazio-engineering/automating-feature-flag-cleanup-at-yazio-from-a-prompt-to-ci-8692fe823570?source=rss-c7cbecad47de------2</link>
            <guid isPermaLink="false">https://medium.com/p/8692fe823570</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[agentic-workflow]]></category>
            <category><![CDATA[ab-testing]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[workflow-automation]]></category>
            <dc:creator><![CDATA[Artem Zasypalov]]></dc:creator>
            <pubDate>Mon, 05 Oct 2026 12:40:46 GMT</pubDate>
            <atom:updated>2026-11-04T08:29:24.482Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*nZcPN4HnPpU-NMS0" /><figcaption>Photo by <a href="https://unsplash.com/@possessedphotography?utm_source=medium&amp;utm_medium=referral">Franck V.</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Remember those days when we thought robots and AI were supposed to take care of tedious things nobody wanted to do? Like washing dishes, taking out the rubbish? My team and I have been working to give AI a less physical version of that job: cleaning up after A/B tests.</p><p>With more things being automated, we are expected to accomplish more as automatable work is often considered at least half done. There is truth to it. But it also means our context switching becomes the norm. A truly useful automation should preserve the focus of engineers as long as possible, meaning it should be able to act trustworthily without approval for as long as possible within the workflow. At the same time, critical stages should still be approved by a human. The definition of the critical stage might change over the next years with further advancements in AI and autonomous software development. Right now at Yazio, we consider merging a PR a critical stage that should be done under a human’s oversight.</p><p>We started experimenting with automated workflows that include AI coding agents over a year ago. Feature flag cleanup was one of the first ones for us to automate. Over several iterations, this effort has grown from a small 64-line prompt into an autonomous workflow, with an engineer only at the critical stage. I’d like to share our journey.</p><h3>Where cleanup starts</h3><p>Our A/B testing lifecycle has 3 core stages: Preparation, Running, and Cleanup. The Cleanup stage begins when the Product Manager chooses one of the 3 options after the test is stopped:</p><ul><li>📦 <strong>Keep the flag</strong> if it still serves a purpose, for example, a feature config.</li><li>🔄 <strong>Update the code default</strong> if we want to roll out a variation as the new baseline while keeping the flag for another iteration.</li><li>🗑️ <strong>Remove the flag</strong> if we decide to roll out one variation permanently.</li></ul><p>The workflow we designed covers the third case.</p><p>The old process required me or someone else to pick up the A/B ticket, create an engineering task to remove the flag, collect the details, and make sure it will be picked up from the backlog.</p><p>Our pace of experimentation made this stage a bottleneck. Squads even had a metric for how many experiments could remain in the cleanup stage. Because such tasks represent the existence of clearly known technical debt. Each of them is either a dead screen, an unused logic branch, or even a resource we no longer need.</p><h3>Step 1: Automating myself &amp; guiding the model</h3><p>First, I decided to automate the most obvious part of the workflow: myself. Creating an engineering ticket, linking it to the experiment, and bringing over the useful data from Growthbook (our experimentation platform). That looked like a straightforward Jira automation. Except humans add much more uncertainty to this equation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Zdl7kmtWVimzudsT6nB8jg.png" /><figcaption>Without any context, AI can’t know with certainty which variant should be kept.</figcaption></figure><p>We are beautifully messy. An “inconclusive” experiment might mean we want to keep the baseline. But we might also want to keep a variation because the change is a rebranding task, and even though there is no clear winner, we still keep a refreshed design. So we also need the product decision to start.</p><p>While working on this I realized that I was gathering context which engineer would probably copy into a coding agent anyway. So why not skip the handoff step then?</p><p>I started creating a prompt with instructions for the cleanup. The first 64-liner covered code-generated flag, YAML declarations, cleaning up usages, retaining chosen variation, linting, verifying project build, and preparing the branch for PR. It contained handling instructions for our custom solutions an agent might encounter along the way. Also, I added a Jira connector so the engineer could just drop a ticket link and the agent would do the rest.</p><p>The first results were encouraging. Still, we had multiple issues wth leftovers, dummy variables that sometimes were even blocking the agent from cleaning up certainly obsolete code, like a retained variable with an assigned static value instead of a flag check:</p><pre>val displayGreenButton = true</pre><p>There was no flag anymore, but a variable remained. Feedback from the team helped us improve instructions. The models improved along the way too. Still, there were many manual steps around the simplified execution step.</p><h3>Step 2: Moving the workflow to CI</h3><p>During an internal company hackathon, a team of engineers made a great step forward. They moved the cleanup skill into a cloud workflow. In the next weeks, it was running in GitHub CI, using Kotlin scripts for parts of the Jira integration.</p><p>This meant we connected ticket preparation and code cleanup together to the point that AI manages the whole handoff. When a manager moves the experiment to “Remove the Feature Flag from code” status, the workflow manages the process without human intervention until the PR is open. And even then, the review agent provides a preliminary review.</p><p>Cool, right?</p><p>Well, turns out AI needs even more guidance than we initially dreamed of. The first CI version could only handle experiments with 1 feature flag. Otherwise, the workflow was stopping with an error. And often the failed workflow requiring an engineer to dig into CI logs was just a 2+ flags experiment that didn’t pass the gate. Sometimes the whole process was taking more time than doing the cleanup for a particular case manually.</p><p>Moving the skill to CI had exposed problems that were easy to handle live by an engineer. The next iteration goal became obvious: better reporting and boundaries for execution.</p><h3>Step 3: making it reliable</h3><p>3 key improvements were introduced last month as the latest iteration so far.</p><h4>1. One flag per commit. Many flags possible. Fresh context per flag.</h4><p>From now on, the workflow is able to process several flags one at a time sequentially, giving each agent run a fresh context with a spec per flag to be removed. After it is done, the agent commits the change, and the workflow moves to the next step until the list of flags to handle is complete.</p><p>Our codebase is large enough so that having one agent run to cover multiple flags risks exhausting the context fast enough to decide it is not a reliable approach. The project also has several custom solutions that should be preserved in particular places, but not applied elsewhere.</p><p>A smaller spec gives each agent one focused task to solve. Separate commits help reviewers trace the decision chain and inspect it rather than just sign off to merge.</p><h4>2. Separated experiment results and the decision</h4><p>The earlier version of the workflow couldn’t handle inconclusive experiments because Growthbook doesn’t identify a winner in these. But the fact that there is no winner does not necessarily mean there is no decision.</p><p>Now we provide the agent with the decision field from Jira, where the product manager records which variation should remain. The agent is also instructed to cross-check it with Growthbook. That field is free text, so this is the part where AI helps to handle non-deterministic input and recognize conflicting information, like if Growthbook has a recorded winner, but Jira says to choose another one. In this case, the agent will flag the contradiction and will skip such a flag.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*99wDcnEf06MCfO7OIXBXLw.png" /></figure><p>This change made most inconclusive experiments eligible for automated cleanup.</p><h4>3. Bring outcome up and visible.</h4><p>Before launching a coding agent, the workflow prepares a spec for each flag. If the agent fails to complete the task, it is instructed to provide reasoning, which will be picked up by the workflow and surfaced in a Jira comment on the ticket. Every skipped flag comes with an explanation too.</p><p>Similarly, if any of the workflow’s gates are not passed, the workflow sends the recorded error log to Jira so the reason will be clear without opening another link and logs.</p><p>And a successful run (which means at least 1 flag removed and the PR is opened) comments the ticket, providing a link to the PR.</p><p>This change not only improves transparency of the execution and streamlines troubleshooting, but also improves overall trust. An engineer expects a failure being clearly stated while completion being clearly linked for them to step in.</p><h3>What numbers show</h3><p>Over almost a year with the workflow, it has created <strong>237 tasks</strong> across all mobile squads. Our internal reporting shows the following median time from the workflow initialization (A/B test moved to Cleanup state) to PR creation:</p><p>🐌 Before the local prompt: 32 days<br>🚙 With the local prompt or skill: 17 days<br>⚡ With the CI workflow: 5 days</p><p>In the second half of 2025, the cleanup backlog grew from <strong>11 to 52 tickets</strong>. Even though the local skill was available at the later stage of that time, someone still had to pick up each task and run it on their machine.</p><p>At the beginning of 2026, the mobile department pushed for backlog reduction. With the skill available, we brought the backlog down to <strong>14 open tickets</strong>. Since then, the CI workflow was introduced, and the backlog stayed between <strong>5 and 15 open tickets</strong>.</p><p>The number of YAML feature flag files dropped from <strong>227 in January to 163</strong>. The median successful CI run takes about <strong>15 minutes</strong> and deletes about <strong>243 lines across 7 files</strong> per run.</p><p>The September improvements have only been running for about ten days. We can describe the capabilities they added, but their effect on the backlog still needs time to become visible.</p><h3>What we learned by automating cleanup</h3><p>A useful cleanup workflow needs to know what to keep and which principle to follow in the custom solution. And then it needs to tell the engineer what happened and why. The model takes just a part of the whole work. Tools, context, and connections around it can be helpful.</p><p>In large brownfield projects with many custom solutions, AI needs special attention to follow instructions. Sometimes just reading the codebase is not enough to make a good judgment about every approach, such as our <a href="https://medium.com/yazio-engineering/configurable-features-using-kotlin-multiplatform-12e7c1c57221?sharedUserId=a.zasypalov">Configurable Features</a>. Documenting how to work with them and stating a vision on which approach should be preserved in the project can help the model to generate a more accurate solution.</p><p>As we saw in this article, humans can be messy, unpredictable, and seen as an obstacle to fast and lean algorithms writing code with a speed beyond our comprehension. But we shouldn’t forget for whom it matters what we do. That’s why we build AI workflows around the people using them. The goal is to give more time and cognitive energy to engineers creating. This helps us have a higher impact on the overall company’s goals and create delightful user experiences.</p><p>Our version of the Feature Flag Cleanup workflow will receive further improvements to become more reliable and trustworthy. It already saves time and automates one of the boring, repetitive yet crucial tasks that helps to keep the codebase operational and accessible while preserving engineers’ focus time, allowing us to ship more sustainably.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*AMQrSHKSOVSDQ-aQ" /><figcaption>Photo by <a href="https://unsplash.com/@marcobian?utm_source=medium&amp;utm_medium=referral">Marco Bianchetti</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8692fe823570" width="1" height="1" alt=""><hr><p><a href="https://medium.com/yazio-engineering/automating-feature-flag-cleanup-at-yazio-from-a-prompt-to-ci-8692fe823570">Automating feature-flag cleanup at Yazio: from a prompt to CI</a> was originally published in <a href="https://medium.com/yazio-engineering">Yazio Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Configurable Features using Kotlin Multiplatform]]></title>
            <link>https://medium.com/yazio-engineering/configurable-features-using-kotlin-multiplatform-12e7c1c57221?source=rss-c7cbecad47de------2</link>
            <guid isPermaLink="false">https://medium.com/p/12e7c1c57221</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[mobile-app-development]]></category>
            <category><![CDATA[kotlin-multiplatform]]></category>
            <category><![CDATA[feature-engineering]]></category>
            <category><![CDATA[product-development]]></category>
            <dc:creator><![CDATA[Artem Zasypalov]]></dc:creator>
            <pubDate>Wed, 30 Aug 2023 09:48:19 GMT</pubDate>
            <atom:updated>2023-09-01T06:55:38.195Z</atom:updated>
            <content:encoded><![CDATA[<p>At YAZIO we love working efficiently. All business logic of our app’s new features is written using Kotlin Multiplatform, and we share its code up to the ViewModels. This approach reduces engineering effort, increases stability, and conserves resources.</p><p>We are always on the lookout for the next step. Some screens and even entire features require swift reactions in changing situations to provide the highest level of experience to our users. The first candidate was Onboarding. Our creative Product Team strives for excellence in first user impressions, meaning that changes in this part of the app occur more frequently than in others.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ElNBj6rZsW-0JTFh71EL4w.jpeg" /></figure><p>That’s why our Development department decided to make this feature not just flexible for content changes, but fully configurable. This means that engineering effort will be reduced to zero for changes that involve only existing Screen Types. Here comes our first term. A <strong><em>Screen Type</em></strong> is a combination of layout and business logic used for the screen in a Flow. And a <strong><em>Flow</em></strong> is a sequence of screens presented to a user in the feature.</p><p>Our goal was to provide the Product team with a way to construct Flows and use them in the app without code changes. We took advantage of Kotlin Multiplatform again. First, we decided to have a single source of truth for both the app and the <strong>Flow Configurator</strong>. Configuration data structures and their validations are in a separate multiplatform module. This module is shared between our KMM client library with business logic and the Compose Desktop Flow Configurator app.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*32Vx8zigCJOSk0I_whWRKA.png" /></figure><p>In the Configurator, we can use our Screen Types to create screen instances and connect them to construct a Flow, create branching to cover all user’s questions and concerns, and experiment with content and screen sequences. The saved configuration is then exported and used in the YAZIO mobile app.</p><p>By delegating responsibility for screen sequences and content, we didn’t neglect the safety of our solution. Each flow undergoes a series of validations to ensure there are no traps (cycle paths) or unreachable questions, and that tracking ids and content ids are correct. This way, we can be confident that the client app will not break due to a Flow Configurator user’s mistake. This allows for worry-free experimentation with the entire feature.</p><p>On the client side, the feature configurability option is designed to be scalable. This means that when we decide to make another feature configurable, we only need to replicate a Flow’s Coordinator that takes care of providing the right ViewModels with the right data for screens and define the screen types the new feature will be compatible with. Using Kotlin Multiplatform, we created a platform-agnostic solution that manages ViewModels and their states, event tracking, and navigation through the feature screens graph. Currently, we have several configurable features released.</p><p>There are other solutions to achieve the same result or even build a server-driven UI, but the advantage of our solution is a fully native UI, shared logic, modularity, and scalability. That’s why we decided to do it ourselves. This approach allowed us to have configurable features without incurring huge upfront costs. After just a month, we were able to deliver the first fully functional version of the Configurator and have one configurable feature. Subsequent features requiring configurability were added in a matter of days.</p><p>The results of this initiative are still being evaluated, but we can already say with certainty that the journey was worth it. We once wondered what if all screens from Onboarding were done in code only? Currently, there are more than 100 screens in total (there are many branches, of course, one user won’t see all of them). The lack of freedom for minor changes and creativity, and the increasing amount of engineering effort to support, are things of the past.</p><p>Screen sequences, content, types, and layouts are changing, but thanks to the implemented solution, engineers can focus on other initiatives to create a better nutrition app for everyone.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*zewF8wKiAXTsKoAXncXkkQ.png" /></figure><p>One important detail that occurred during this initiative: our iOS engineers were involved in the process of designing and implementing this solution and were able to gain hands-on experience in using Kotlin Multiplatform. Involving iOS team members is crucial for the long-term sustainability of the whole Multiplatform approach. Solving problems on both platforms and growing together not only as Android or iOS engineers but as Mobile Engineers who still deliver a 100% native UI experience to users is the unique career opportunity that we offer at YAZIO.</p><p>In this article, we provided an overview of the beginning of our journey with configurable features. This journey continues, and we can’t wait to share details about what went well, where we decided to refactor, how we experienced scaling challenges, and more technical details. Stay tuned!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=12e7c1c57221" width="1" height="1" alt=""><hr><p><a href="https://medium.com/yazio-engineering/configurable-features-using-kotlin-multiplatform-12e7c1c57221">Configurable Features using Kotlin Multiplatform</a> was originally published in <a href="https://medium.com/yazio-engineering">Yazio Engineering</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>