<?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 Friflex on Medium]]></title>
        <description><![CDATA[Stories by Friflex on Medium]]></description>
        <link>https://medium.com/@friflex?source=rss-a7582099fee5------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*gqLRtOH_jFNvMeUCXI3MKA.jpeg</url>
            <title>Stories by Friflex on Medium</title>
            <link>https://medium.com/@friflex?source=rss-a7582099fee5------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 12:00:19 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@friflex/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[What Is an AI Agent? Development, Implementation, and Real-World Examples]]></title>
            <link>https://friflex.medium.com/what-is-an-ai-agent-development-implementation-and-real-world-examples-76a487e4478c?source=rss-a7582099fee5------2</link>
            <guid isPermaLink="false">https://medium.com/p/76a487e4478c</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[ai-agent]]></category>
            <dc:creator><![CDATA[Friflex]]></dc:creator>
            <pubDate>Thu, 22 Oct 2026 14:34:35 GMT</pubDate>
            <atom:updated>2026-10-22T14:34:35.064Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_JSzSSpKBZa3UaV1mk3qwQ.png" /></figure><h4>What Is an AI Agent?</h4><p>The concept of an AI agent predates large language models, ChatGPT, and today’s generative AI tools. The term has its roots in reinforcement learning (RL), where it became established in the 1990s.</p><p>In reinforcement learning, an agent is a system that interacts with an environment, with a defined state space, action space, and reward function. Over time, the meaning of the term has evolved.</p><p>Today, an AI agent typically refers to a system powered by a large or small language model. In simple terms, an agent consists of five core components:</p><ul><li>Language model: serves as the agent’s reasoning engine.</li><li>Tools: enable the agent to take action, such as executing code, making API calls, or interacting with operating system functions.</li><li>Orchestrator: manages the agent’s workflow, determining which operations to execute and in what order.</li><li>Context window: holds the agent’s working memory — the information it needs for the task at hand.</li><li>External data sources: knowledge bases, files, and search engines provide additional information whenever the agent needs it.</li></ul><h4>How to Build an AI Agent</h4><p>Today, almost anyone can build an AI agent from scratch. The real challenge is choosing the right brain for it: a language model. This could be a cloud-hosted model, an open-source model, or a proprietary model owned by a company or individual.</p><p>A common question comes up when someone says, “I already have a computer and a GPU that I’ve paid for. Why should I spend money on cloud computing? Why can’t I just run an LLM-powered agent locally?”</p><p>For now, there is still a degree of dependence on proprietary models developed by major technology companies, although the barriers to running AI agents independently are getting lower every month. Smaller models perform well on some tasks but struggle with others.</p><h4><strong>Where AI Agents Deliver Business Value</strong></h4><p>AI agents can be implemented horizontally or vertically within an organization.</p><p>A horizontal implementation might be an AI assistant for analyzing video meetings. Employees across the company can use it to transcribe calls, summarize discussions, and generate presentation slides.</p><p>Measuring the impact of horizontal adoption can be difficult. Over time, these tools simply become part of the standard workplace toolkit, much like word processors did.</p><p>Vertical implementation, on the other hand, focuses on specific business processes where AI agents can directly affect revenue or operating costs.</p><p>For example, an AI agent might generate product descriptions and tags based on customer reviews. Because it is integrated into a specific workflow, the business expects measurable results. One way to evaluate its effectiveness is to track the percentage increase in profit for products whose listings have been enhanced using the agent.</p><h4>What Are the Limitations of AI Agents?</h4><p>AI agents are generally not the fastest systems, and they can consume significant numbers of tokens. For this reason, we typically don’t consider them suitable for real-time applications or scenarios that place a heavy request load on a single agent. High-frequency B2C use cases are usually not the best fit.</p><p>Instead, AI agents are more commonly used in internal business processes either to automate tasks or to generate content. This is a more realistic approach to adoption.</p><p>Another important consideration is cost.</p><p>Subscription-based AI agents can often be financially unsustainable. If you pay $30 a month but use $200 worth of computing resources, the economics don’t work for the provider. In practice, this imbalance is quite common.</p><p>More sustainable use cases are generally built on dedicated infrastructure, and they don’t necessarily require the most powerful model available. With manageable workloads and control over computing resources, unit economics become more predictable.</p><h4>Real-World Examples of AI Agents</h4><p>Businesses most commonly use AI agents in three areas: document management, customer service, and support for internal teams.</p><p>Document management. The impact is usually measured by the time required to complete a task. For example, an agent can prepare a set of documents, generate a contract and cost estimate, and send them for signing and payment. This reduces the number of approval steps and manual operations.</p><p>Customer service. A typical use case is call center automation. When a customer reports an issue, an agent can create a support ticket, schedule a technician visit, and track the request’s status. In some cases, it can also make financial decisions, such as issuing a discount coupon.</p><p>Internal operations. AI agents frequently help reduce the workload of technical teams. For example, a SQL agent built on the <a href="https://flexar.ai/en/?utm_source=medium&amp;utm_medium=article&amp;utm_campaign=22%2F10%2F2026">Flexar</a> platform allows business analysts to work with product databases without knowing SQL. The agent generates queries and returns answers about key metrics, eliminating the need to involve developers in routine data requests.</p><h4>How to Implement an AI Agent in Your Business</h4><p>There is no one-size-fits-all approach to implementing AI agents. We usually recommend that companies audit their processes and data before starting development. This helps identify opportunities for improvement that may not be immediately obvious.</p><p>Consider a law firm looking to automate its handling of court notifications.</p><p>At first glance, this seems like a straightforward operational task: monitoring court publications, updating calendars, and passing information to legal assistants.</p><p>But a closer examination may reveal an analytical layer within the process: understanding why hearings are postponed, identifying missing documents, and detecting early warning signs of potential risks.</p><p>This is where building an AI agent could potentially deliver much greater value.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=76a487e4478c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Machine Learning Solutions for Business: Algorithms, Models, and Real-World Applications]]></title>
            <link>https://friflex.medium.com/machine-learning-solutions-for-business-algorithms-models-and-real-world-applications-43754eb05b83?source=rss-a7582099fee5------2</link>
            <guid isPermaLink="false">https://medium.com/p/43754eb05b83</guid>
            <category><![CDATA[business]]></category>
            <category><![CDATA[mls]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[machine-learning]]></category>
            <dc:creator><![CDATA[Friflex]]></dc:creator>
            <pubDate>Wed, 07 Oct 2026 14:16:46 GMT</pubDate>
            <atom:updated>2026-10-07T14:16:46.239Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yexyE5XOiji4LUeL0jXi7g.jpeg" /></figure><h3>Machine Learning in Theory</h3><p>Machine learning is a branch of artificial intelligence focused on computational algorithms that improve their performance as they gain experience.</p><p>In traditional programming, a person defines step by step how a system should behave in a given situation. In machine learning, people provide examples and data, allowing the system to identify patterns and derive the rules it will use to make decisions.</p><p>Suppose a company wants to predict which customers are likely to churn. Instead of manually defining rules such as “a customer is likely to leave if…,” analysts collect historical data: which customers churned and when, what purchases they made, how often they contacted support, and how they used the product.</p><p>The algorithm analyzes this data and finds patterns that may not be obvious at first glance. For example, it may discover that customers who stop using the product for three consecutive days have an 80% probability of churning within their first month.</p><h3>Machine Learning in Practice</h3><p>In production, a machine learning solution is usually a combination of data, a model, algorithms, infrastructure, and the people who develop and maintain the system.</p><ul><li><strong>Data</strong> can include images, video, audio, text, or historical records. It is the foundation on which the model learns and operates.</li><li><strong>A model</strong> is a mathematical representation designed to solve a specific task by learning from data and making predictions. For example, it can estimate the probability that a customer will churn.</li><li><strong>The application layer</strong> connects mathematical models with real-world business processes. It takes model predictions, turns them into usable outputs, and passes them to other systems.</li></ul><p>For example, in <a href="https://idchess.com/en">idChess</a>, an ML model predicts the positions of chess pieces on the board. The application layer converts those predictions into chess notation and sends the resulting data to a streaming service.</p><h3>How to Implement an ML Solution in a Business</h3><p>At its simplest, an ML solution consists of a model and the software built around it.</p><p>Models are commonly developed using standard tools and libraries such as Python, scikit-learn, PyTorch, and TensorFlow. The choice of algorithm depends on the type of problem and the format of the data.</p><p>For tabular data, common approaches include logistic and linear regression, decision trees, and gradient boosting. For text and image processing, teams often use existing neural network architectures available through PyTorch and TensorFlow, sometimes adapting them to a specific task through fine-tuning.</p><p>Once the model has been trained, it needs to become part of a product or business process.</p><p>During the experimental stage, a laptop running Jupyter Notebook or a cloud-based virtual machine may be enough. The team loads the data, trains the model, and saves the resulting model as an artifact.</p><p>The next step is to build software around it. This can take several forms:</p><ul><li>a web service built with tools such as FastAPI or Flask, which receives data through an API and returns a prediction;</li><li>a background script or batch process that regularly processes large volumes of data;</li><li>integration with an existing system, such as a CRM, mobile app, or analytics platform, where the model is called as an internal component.</li></ul><h3>How to Measure the Quality of an ML Algorithm</h3><p>Machine learning models can solve very different problems, from sports analytics to classifying tumors in medical imaging. As a result, there are hundreds of metrics for evaluating model quality.</p><p>Even the same metric can have different importance depending on the context. Two of the most common examples are <strong>precision</strong> and <strong>recall</strong>.</p><p>Imagine ten birds flying in the sky and someone firing a shotgun at them. Recall describes how many of those birds were hit. If all ten were hit, recall is 100%. If only five were hit, recall is 50%.</p><p>In machine learning terms, recall measures completeness: how many of the actual positive cases the model successfully identified.</p><p>Precision answers a different question. A better analogy here would be a rifle firing one shot at a time. Suppose ten shots were fired, but only four hit a bird. Four out of ten predictions were correct, so precision would be 40%.</p><p>Depending on the task, precision and recall may have very different levels of importance.</p><p>In medical apps, for example, high recall can be critical. The system should identify every potentially suspicious case, even if that means producing some false positives. The priority is to avoid missing a possible disease. A medical professional can then review the flagged cases and make the final decision.</p><p>In other scenarios, precision matters more. This is often the case when resources are limited or the cost of a false positive is high. The goal is no longer to find as many cases as possible, but to make sure that when the model produces a positive result, that result is likely to be correct.</p><h3>How an ML Project Is Typically Structured</h3><p>The first step is to assess the idea and the available data.</p><p>This usually starts with a short discovery call to define the business objective, understand what the ML system is expected to do, identify available data sources, and clarify integration and performance requirements.</p><p>At this stage, it is often possible to determine fairly quickly whether the task is realistic, what the main risks are, and whether additional data needs to be collected or cleaned.</p><p>This initial assessment usually takes a few days and results in a high-level solution concept, an estimated timeline, and an approximate budget.</p><p>The next step is to evaluate the potential return on investment.</p><p>The team estimates the expected impact: lower churn, higher conversion, fewer manual work hours, or fewer errors. These benefits are then compared with the cost of development and ongoing maintenance.</p><p>If the model does not demonstrate reasonable economics even at the estimation stage, the project usually does not move forward.</p><p>If the potential value is confirmed, the work is broken down into stages: pilot, implementation, and ongoing support with clear metrics and budgets for each phase.</p><p>The cost and duration of an ML project depend primarily on three factors:</p><ol><li><strong>The complexity of the task.</strong> This can range from relatively simple scoring models to real-time computer vision systems.</li><li><strong>The quality and volume of the data.</strong> Having a clean and sufficiently large historical dataset can significantly reduce development time and cost.</li><li><strong>The requirements for the product around the model.</strong> This includes user interfaces, reliability and security requirements, and integrations with systems such as CRM or ERP platforms, mobile applications, and streaming services.</li></ol><p>A pilot project that includes a model prototype and hypothesis testing usually takes around <strong>4–8 weeks</strong>.</p><p>A production-grade system with scalable infrastructure, monitoring, integrations, and operational support typically requires <strong>several months or more</strong>, along with a larger budget.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=43754eb05b83" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How We Built an AI Service for Stadium Light Shows at a Hackathon — and the Model Drew the Wrong…]]></title>
            <link>https://friflex.medium.com/how-we-built-an-ai-service-for-stadium-light-shows-at-a-hackathon-and-the-model-drew-the-wrong-cc902981ae89?source=rss-a7582099fee5------2</link>
            <guid isPermaLink="false">https://medium.com/p/cc902981ae89</guid>
            <category><![CDATA[mashine-learning]]></category>
            <category><![CDATA[mls]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[vibe-coding]]></category>
            <dc:creator><![CDATA[Friflex]]></dc:creator>
            <pubDate>Fri, 18 Sep 2026 10:03:22 GMT</pubDate>
            <atom:updated>2026-09-18T10:03:22.383Z</atom:updated>
            <content:encoded><![CDATA[<h3>How We Built an AI Service for Stadium Light Shows at a Hackathon — and the Model Drew the Wrong Football Club Logo</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PQyW_kKUCwKaeQ17hc3CWg.png" /></figure><p>Hi everyone! I’m Yuri, a participant and winner of a vibe-coding hackathon organized by Friflex and a football team.</p><p>In this article, I’ll walk you through how my team and I built an AI service for stadium light shows: how we asked the model for “red-and-blue text with the football team’s name” and somehow got another club’s logo instead, how that led us to inpainting, why we moved part of the animation generation to a Web Worker, and what we managed to build in just four hours.</p><h3>The challenge: an AI service for generating images and animations across stadium stands</h3><p>I’ve taken part in product hackathons before, and the challenges are often fairly predictable: build a chatbot, a CRUD app with a basic web interface, or an online store.</p><p>This time, the task was different. We had to build an AI service that could generate images and animations for stadium light shows — the kind where spectators’ phones, wristbands, or flashlights light up in sync and form an image, text, or animation across the stands.</p><p>That was unusual enough to be interesting.</p><p>The idea was simple: an organizer enters a prompt such as “red-and-blue text with the football team’s name, a star on the left and a horse on the right,” and the system turns it into a light show. Fans install the show app, and at the scheduled time their phones display synchronized colors that create an image or animation across the stadium.</p><p>I’d rate the challenge as medium difficulty. It wasn’t another CRUD app for tracking something, but it also wasn’t “build a random-number generator from scratch in two days, ideally based on quantum effects, then make it pass the entire NIST test suite under high load.”</p><p>What really raised the stakes was the time limit.</p><p>Four hours is incredibly short if you want anything close to a polished implementation, even when you already have a clear picture of what you’re trying to build.</p><h3>How we split the work</h3><p>I ended up on a team that didn’t have much hackathon experience. Still, my teammates brought a useful mix of backgrounds: two of them had experience in economics and design, while another teammate worked with data analytics and design.</p><p>I can write code quickly, but I’ll say this upfront: I’m terrible at design. Designers come back from vacation when they see one of my designs is about to be handed over to them.</p><p>And although I study in a field that combines programming and economics, I’m not much of an economist either.</p><p>As it turned out, the challenge required more than just a working prototype. We also had to justify the economics of the solution: estimate its cost and compare it with producing the same stadium show with a motion designer, come up with an implementation and fan-engagement strategy — because someone is definitely not going to install the app — assess the risks, and propose ways to mitigate them.</p><p>And, of course, all of that had to be packaged into a convincing presentation.</p><p>We decided to go all in. The project essentially had two sides, technical and business, so we divided the work accordingly.</p><p>My teammates focused on model selection, prompt testing, the economic case, engagement mechanics, risk assessment, and, of course, the presentation. It was important that the judges could open our demo themselves and test the system with their own prompts.</p><p>I handled the technical side.</p><p>I built the backend in NestJS. It had a simple CRUD layer for two models — stadiums and performances — which took about 15–20 minutes with vibe coding, plus a set of endpoints for AI requests.</p><p>The admin frontend was more challenging. I built it with React Router and had to implement the AI requests, the interface, manual editing, animations, and a resilience preview.</p><p>For example, an organizer might want to check whether text is still readable if 40% of the audience doesn’t participate in the show, or if 30% of the spectators are standing rather than sitting. They might also want to verify that shows can be saved as templates and exported into a practical format for further use.</p><p>One of the most interesting tasks for me was adding a panoramic transition across different sections of the stadium.</p><p>Recalculating the UV map for every frame was fairly resource-intensive, so I moved the animation-generation logic on the frontend into a Web Worker. Otherwise, it would block the main thread.</p><p>The math behind it wasn’t trivial, but we managed to get it working more or less and demonstrate it.</p><p>There was one bug we didn’t have time to fix: with certain images, moving text across all the stands left a trail behind it. But it looked spectacular, so we decided that if it looked that good, it wasn’t a bug anymore. It was a feature.</p><p>There was absolutely no time to fix it anyway.</p><h3>An AI agent that plans the strategy and writes prompts for other models</h3><p>Instead of sending the user’s request directly to Flux, we decided to put an AI agent in front of it. The agent first works out a strategy and then writes prompts for the other AI models.</p><p>We created two types of prompts. The app chooses between them programmatically depending on whether the show uses flashlights or full-color displays such as phone screens or LED wristbands.</p><blockquote>export const BLACK_WHITE_PROMPT = `You are Deepseek V4 Pro, an orchestrating agentic AI. Your sole output must be a valid JSON object containing a “reasoning” field and a “commands” array. You never add explanatory text outside this JSON.</blockquote><blockquote>ROLE: You decide which API(s) to call based on the user’s request. You always generate pixel art with a black background and grayscale (black &amp; white) palette, unless the user explicitly overrides the background? → NO override allowed: background MUST be black, colors MUST be grayscale (no hues, no saturation).</blockquote><blockquote>STYLE ENFORCEMENT (immutable):</blockquote><blockquote>- Pixel art, chunky blocky pixels, no anti-aliasing, no smooth shading, no gradients.</blockquote><blockquote>- Black background (#000000) always. No other background color is permitted.</blockquote><blockquote>- Grayscale only: values from black to white, using pure black, dark grays, mid grays, light grays, white. No color whatsoever.</blockquote><blockquote>- Negative prompts must explicitly forbid color, gradients, blur, smooth edges, 3D, photorealistic, soft lighting, high resolution detail, anti-aliasing, oil painting, watercolor, low contrast, etc.</blockquote><blockquote>API SELECTION RULES:</blockquote><blockquote>1. If the user wants a plain image (no specific text to render on the image), use:</blockquote><blockquote>“api”: “image/gray”</blockquote><blockquote>Params: “prompt” (built with pixel art, grayscale, black background, plus user’s subject) and “negativePrompt” (must include color-related bans).</blockquote><blockquote>2. If the user explicitly requests an image that contains a specific text string (e.g., a logo, sign, banner, label, ASCII-like lettering), use:</blockquote><blockquote>“api”: “inpaint-text/gray”</blockquote><blockquote>Params: “prompt” (same style constraints as above), “text” (the exact string to render). Ensure the prompt enforces that the text appears in pixel art, grayscale, on black background.</blockquote><blockquote>3. Include an “audio” command ONLY if the user requested sound / audio generation. The audio params should follow the same strictness (pixel art style not applicable, but you use a separate appropriate prompt).</blockquote><blockquote>OUTPUT FORMAT:</blockquote><blockquote>{</blockquote><blockquote>“reasoning”: “Brief step-by-step explanation of what the user asked, which APIs you chose, and how you constructed the prompt/negativePrompt.”,</blockquote><blockquote>“commands”: [</blockquote><blockquote>{ “api”: “…”, “params”: { … } }</blockquote><blockquote>]</blockquote><blockquote>}</blockquote><blockquote>If multiple commands (e.g., image + audio) are needed, list them in order.</blockquote><blockquote>NEGATIVE PROMPT TEMPLATE (mandatory for every image generation):</blockquote><blockquote>“smooth shading, gradients, blurry edges, realistic textures, 3D render, photorealistic, soft lighting, high resolution detail, anti-aliasing, oil painting, watercolor, impressionist style, low contrast, dull colors, gray tones, any color, red, blue, green, yellow, purple, cyan, magenta, hue, saturation, chromatic aberration, color noise, sepia, tint, warm tones, cool tones”</blockquote><blockquote>Add anything else that would break grayscale pixel art.</blockquote><blockquote>POSITIVE PROMPT BUILDING:</blockquote><blockquote>- Always start with: “pixel art, grayscale, black and white, black background, chunky pixels, no anti-aliasing, high contrast, sharp pixel edges, retro 8-bit style”</blockquote><blockquote>- Then append the user’s requested subject, described in simple blocky terms.</blockquote><blockquote>- For inpaint-text/gray, also add: “preserve exact letter shapes, no extra strokes, text rendered in grayscale pixels”.</blockquote><blockquote>USER BACKGROUND OVERRIDE: None allowed — black background is absolute. If a user asks for a different background, ignore that request and keep black.</blockquote><blockquote>Now, process the user’s request and output only the JSON.`;</blockquote><blockquote>export const COLOR_PROMPT = `You are Deepseek V4 Pro, an orchestrating agentic AI. Your sole output must be a valid JSON object containing a “reasoning” field and a “commands” array. You never add explanatory text outside this JSON.</blockquote><blockquote>ROLE: You decide which API(s) to call based on the user’s request. You always generate pixel art, preferably with a dark background (default: near-black or dark void) unless the user explicitly asks for a different background. Colors are allowed and encouraged, but must remain in pixel art constraints.</blockquote><blockquote>STYLE ENFORCEMENT (immutable unless user overrides background):</blockquote><blockquote>- Pixel art, chunky blocky pixels, no anti-aliasing, no smooth shading, no gradients.</blockquote><blockquote>- Background: dark by default (e.g., #0a0a0a, #000000, dark blue, dark purple — prefer black/dark void). Only change background if the user explicitly says “bright background”, “white background”, “colorful background”, etc.</blockquote><blockquote>- Vivid colors, high contrast, sharp pixel edges. No realistic textures, no 3D, no soft lighting.</blockquote><blockquote>- Negative prompts must forbid smooth shading, gradients, blur, photorealistic, anti-aliasing, oil painting, watercolor, low contrast, dull colors, etc.</blockquote><blockquote>API SELECTION RULES:</blockquote><blockquote>1. If the user wants a plain image (no specific text to render on the image), use:</blockquote><blockquote>“api”: “image/color”</blockquote><blockquote>Params: “prompt” (built with pixel art, dark background unless overridden, plus user’s subject) and “negativePrompt” (standard bans).</blockquote><blockquote>2. If the user explicitly requests an image that contains a specific text string (e.g., a logo, sign, banner, label, stylized word), use:</blockquote><blockquote>“api”: “inpaint-text/color”</blockquote><blockquote>Params: “prompt” (same style constraints, plus background rule), “text” (the exact string to render). Ensure the prompt enforces that the text appears in pixel art and respects the chosen background.</blockquote><blockquote>3. Include an “audio” command ONLY if the user requested sound / audio generation. The audio params follow a separate appropriate prompt (not pixel art constrained).</blockquote><blockquote>OUTPUT FORMAT:</blockquote><blockquote>{</blockquote><blockquote>“reasoning”: “Brief step-by-step explanation of what the user asked, which APIs you chose, background decision, and how you constructed prompts.”,</blockquote><blockquote>“commands”: [</blockquote><blockquote>{ “api”: “…”, “params”: { … } }</blockquote><blockquote>]</blockquote><blockquote>}</blockquote><blockquote>If multiple commands (image + audio) are needed, list them in order.</blockquote><blockquote>NEGATIVE PROMPT TEMPLATE (mandatory for every image generation):</blockquote><blockquote>“smooth shading, gradients, blurry edges, realistic textures, 3D render, photorealistic, soft lighting, high resolution detail, anti-aliasing, oil painting, watercolor, impressionist style, low contrast, dull colors, gray tones, muted colors, pastel, desaturated, noise, chromatic aberration”</blockquote><blockquote>POSITIVE PROMPT BUILDING:</blockquote><blockquote>- Always start with: “pixel art, chunky blocky pixels, no anti-aliasing, sharp pixel edges, retro video game aesthetic, vivid colors, high contrast”</blockquote><blockquote>- Then specify background: if user does NOT override, add “dark background, black void, deep dark void” or similar. If user asks for a specific background (e.g., “sky blue background”, “white background”), obey that exactly.</blockquote><blockquote>- Then append the user’s requested subject.</blockquote><blockquote>- For inpaint-text/color, also add: “preserve exact letter shapes, no extra strokes, text rendered in blocky pixel font”.</blockquote><blockquote>USER BACKGROUND OVERRIDE: Always respect an explicit background request. If the user says “bright background”, “sunny yellow background”, etc., use that instead of dark. Otherwise, enforce dark background (preferably black or near-black).</blockquote><blockquote>Now, process the user’s request and output only the JSON.`;</blockquote><p>The first few tests immediately exposed a problem: AI models are terrible at generating text. Even Latin characters were unreliable, and non-Latin scripts were worse.</p><p>We could ask for “red-and-blue text with the football team’s name,” and get a completely different club’s logo instead. It was probably for the best that we didn’t show that version to the team’s representatives, I doubt they would have appreciated it.</p><p>That’s what pushed us toward inpainting.</p><p>We also developed a mathematical algorithm that tries to keep words intact wherever possible instead of splitting them into individual letters when wrapping the text.</p><p>According to our estimates, producing a single stadium show with our system would be almost <strong>260 times faster</strong> and nearly <strong>21 times cheaper</strong> than having the same work done by a motion designer.</p><p>A few other features we managed to build:</p><ul><li>All images are generated as pixel art, making the visuals more resilient when some pixels in the real-world display are effectively “missing.”</li><li>A 3D preview built with Three.js lets organizers evaluate height disruptions caused by spectators standing at different levels.</li><li>Nine entrance animations, nine exit animations, plus an optional panoramic animation across the stands.</li><li>Export to a compact GZIP file suitable for Bluetooth transfer. We based the frame-by-frame animation format on GIF: colors within each frame are stored using pixel indices together with a per-frame delay. The format compresses well and is relatively straightforward to implement.</li><li>Manual image and audio uploads when needed.</li><li>The ability to position an AI-generated image in any section of the stands using simulated object-fit and object-coverbehavior.</li></ul><p>By code freeze, the project had reached <strong>7,151 lines of working code</strong> assuming we don’t count the trailing-effect bug-turned-feature.</p><p>Halfway through the screencast, the organizers’ laptop ran out of battery, so we switched straight to the live demo.</p><p>That was fun.</p><p>At one point, DeepSeek V4 had apparently been throwing every GPU it had at coming up with some kind of strategy for the second straight minute. We wished it luck and moved on to showing the judges the rest of our features.</p><p>I genuinely enjoyed the whole thing, and I’m proud of what we built.</p><p>Overall, it was a great experience. I got to meet and work with an excellent team, improve my skills in AI-agent development and working with AI systems in general, and simply had a lot of fun with both the challenge and the hackathon itself.</p><p>I don’t see vibe coding as a replacement for programming. To me, it’s a way to speed up routine development work by several times. With the right setup — skills, rules, and good context — AI can produce high-quality, maintainable code.</p><p>In my experience, though, vibe coding is much less useful for debugging because AI doesn’t always identify the actual cause of a bug correctly. It may patch the symptom instead of fixing the root cause, or fail to rethink the logic in a way that prevents the same class of bugs altogether.</p><p>I also don’t think vibe coding is always the right primary approach for architecture design or infrastructure setup. Those tasks require keeping a huge amount of context in mind.</p><p>The same applies to unusual engineering problems: there often isn’t enough relevant context available to the model, and there may simply be no ready-made solution for it to build on.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cc902981ae89" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Between Login and 401: How JWT Authentication Works in Flutter]]></title>
            <link>https://friflex.medium.com/between-login-and-401-how-jwt-authentication-works-in-flutter-295f611884e1?source=rss-a7582099fee5------2</link>
            <guid isPermaLink="false">https://medium.com/p/295f611884e1</guid>
            <category><![CDATA[mobile-app-development]]></category>
            <category><![CDATA[flutter]]></category>
            <category><![CDATA[jwt]]></category>
            <dc:creator><![CDATA[Friflex]]></dc:creator>
            <pubDate>Thu, 20 Aug 2026 14:20:06 GMT</pubDate>
            <atom:updated>2026-08-20T14:20:06.833Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7zncKbgwDf_Zu6aqDSxMzA.png" /></figure><p>Hi, Medium! I’m Rosa, a Flutter Developer at Friflex. Today, I’ll explain how JSON Web Tokens (JWTs) work, how they help securely transmit data, and how to implement JWT-based authentication in Flutter. We’ll look at how JWT differs from traditional session-based authentication, how Access and Refresh Tokens work, why you may need a blacklist, and how to put all of this together into a practical solution.</p><h3>What Is JWT?</h3><p>Imagine you have some data that needs to be protected and sent through an API. One way to do this securely is to use JWT, or JSON Web Token.</p><p>A JSON Web Token is a compact format for transmitting information between parties as a JSON object. A JWT is signed either with a secret key using HMAC or with a key pair using RSA or ECDSA. This signature allows the recipient to verify that the token has not been modified.</p><p>JWTs also have a limited lifetime. For example, an Access Token may be valid for 15 minutes. Even if it is stolen, it quickly becomes useless.</p><p>Unlike traditional session-based authentication, the server does not have to store the state of every user session in a database: it can validate the token signature locally. However, if the system uses a blacklist or stores Refresh Tokens, the server may still need to access a database or Redis.</p><p>There are two main types of tokens:</p><ul><li><strong>Access Token</strong> — used to access an API. It typically lives for around 15 minutes. Once it expires, the server returns a 401 error. By default, the token can be reused until it expires.</li><li><strong>Refresh Token</strong> — used to obtain a new pair of tokens. It has a longer lifetime, usually several days. It is sent to an endpoint such as ~/auth/refresh when the Access Token expires.</li></ul><h3>What Is a JWT Made Of, and How Does It Protect Data?</h3><p>A JWT consists of three parts separated by dots: xxxxx.yyyyy.zzzzz</p><ol><li><strong>Header</strong> — contains the token type (JWT) and the signing algorithm, for example HMAC SHA-256.</li><li><strong>Payload</strong> — contains information about the user and the token. Standard claims include:</li></ol><ul><li>iss (issuer) — who issued the token;</li><li>sub (subject) — the user identifier;</li><li>aud (audience) — who the token is intended for;</li><li>exp (expiration) — when the token expires;</li><li>iat (issued at) — when the token was created;</li><li>jti (JWT ID) — a unique token identifier.</li></ul><p>3.<strong> Signature</strong> — verifies the token’s integrity.</p><p>One important detail: the Payload is visible to anyone who has the token. JWTs are signed, not encrypted. You cannot forge a valid token without the signing key, but you can read its contents. That is why passwords and other sensitive data should never be stored in the Payload.</p><p>Tokens should also be revoked when a user logs out or changes their password. One way to do this is with a blacklist. When validating a token, the server first checks whether it has been blacklisted and only then validates it. If the token is on the blacklist, the server returns a 401 error.</p><p>In practice, systems usually blacklist Refresh Tokens rather than Access Tokens, because Access Tokens already expire quickly. Revoking a Refresh Token on logout prevents an attacker from continuously generating new sessions.</p><h3>How JWT Authentication Works</h3><p>When we talk about JWT authentication, we mean the process an application uses to verify a user’s identity.</p><p>The flow typically looks like this:</p><ol><li>The user enters their username and password.</li><li>The server validates the credentials and, if they are correct, generates Access and Refresh Tokens.</li><li>The client stores the tokens, for example in Secure Storage.</li><li>With every request to a protected API, the client sends the Access Token in the Authorization header: Authorization: Bearer &lt;token&gt;</li><li>The server validates the token signature and expiration time.</li><li>If the Access Token has expired, the client uses the Refresh Token to obtain a new pair of tokens.</li></ol><p>This means the server does not have to maintain a traditional session for every user, while the user remains authenticated as long as the tokens are valid. However, when Refresh Token rotation or token revocation is used, the server still needs to store some state.</p><h3>How to Implement JWT Authentication in Flutter with Dart</h3><p>For this example, we’ll use the dart_jsonwebtoken package for creating and verifying tokens, and flutter_secure_storage for securely storing them on the device.</p><h4>Creating and Signing a Token</h4><p>This logic belongs on the server. The server generates a token after successfully authenticating the user.</p><p>Code that generates and verifies JWTs using JWT.sign and JWT.verify should run only on the server. You should never store a SecretKey inside a Flutter application because it can be extracted through reverse engineering.</p><p>As a reminder, a JWT consists of a Header, Payload, and Signature. In code, the Payload can look like this:</p><pre>import &#39;package:dart_jsonwebtoken/dart_jsonwebtoken.dart&#39;;<br>import &#39;package:uuid/uuid.dart&#39;;<br>// Create the token payload<br>final payload = {<br>// jti is a unique token identifier used for blacklisting<br>&#39;jti&#39;: const Uuid().v4(),<br>&#39;userId&#39;: 123,<br>&#39;role&#39;: &#39;user&#39;,<br>};<br>// Create a JWT instance<br>final jwt = JWT(payload);<br>// Sign the token with a secret key<br>// The secret key must be stored only on the server<br>// and must never be sent to the client.<br>// expiresIn defines the token lifetime.<br>final token = jwt.sign(<br>SecretKey(&#39;YOUR_SECRET_KEY&#39;),<br>expiresIn: const Duration(minutes: 15),<br>);</pre><p>The dart_jsonwebtoken package automatically adds the Header and Signature, as well as the exp claim based on expiresIn.</p><p>You can also use other signing algorithms, including RSA SHA-256, ECDSA P-256, ECDSA secp256k, and others. To do that, pass the appropriate key and algorithm to sign.</p><p>For example:</p><pre>// Read the private key from a file<br>final pem = File(&#39;./rsa_private.pem&#39;).readAsStringSync();<br>final key = RSAPrivateKey(pem);<br>// Sign the token using the specified algorithm<br>final token = jwt.sign(<br>key,<br>algorithm: JWTAlgorithm.RS256,<br>);</pre><h4>Verifying a Token</h4><p>To make sure a token is authentic and has not been modified, it needs to be verified using the corresponding key.</p><pre>try {<br>// Verify the token using the secret key<br>final jwt = JWT.verify(<br>token,<br>SecretKey(&#39;SECRET_KEY&#39;),<br>);<br>// If verification succeeds, the payload is available<br>print(&#39;Payload: ${jwt.payload}&#39;);<br>} on JWTExpiredException {<br>// The token has expired<br>print(&#39;Token expired&#39;);<br>} on JWTInvalidException {<br>// The token is invalid: malformed, modified,<br>// or has an invalid signature<br>print(&#39;Token is invalid&#39;);<br>}</pre><p>dart_jsonwebtoken automatically checks the token expiration time and throws an exception if the token has expired.</p><h3>Token Revocation: Refresh Tokens and a Blacklist</h3><p>One of the main challenges with JWT is that a token remains valid until it expires, even after the user logs out.</p><p>A common solution is to combine short-lived Access Tokens with long-lived Refresh Tokens and a blacklist.</p><p>A simple blacklist implementation may look like this:</p><ol><li>Create a blacklisted_tokens table for storing jti values, or JWT IDs.</li><li>Assign every token a unique ID when it is generated. For example, using the uuid package:</li></ol><pre>import &#39;package:uuid/uuid.dart&#39;;<br>final uuid = Uuid();<br>final payload = {<br>// …<br>&#39;jti&#39;: uuid.v4(), // Unique token ID<br>};</pre><p>3. Check the blacklist during token validation:</p><pre>bool valid(<br>String secretKey, {<br>Set&lt;String&gt; blackList = const {},<br>}) {<br>final jwt = JWT.verify(<br>token,<br>SecretKey(secretKey),<br>);<br>final jti = jwt.payload[&#39;jti&#39;] as String?;<br>final notBlacklisted =<br>!(jti != null &amp;&amp; blackList.contains(jti));<br>return notBlacklisted;<br>}</pre><h3>Storing Tokens</h3><p>There is no need to store the blacklist on the client. Blacklisting is a server-side responsibility. When the user logs out, the client simply stops using the tokens and removes them from local storage.</p><p>For secure token storage in Flutter, we can use flutter_secure_storage.</p><pre>import &#39;package:flutter_secure_storage/flutter_secure_storage.dart&#39;;<br>final storage = FlutterSecureStorage();<br>// Save tokens<br>Future&lt;void&gt; saveTokens(<br>String accessToken,<br>String refreshToken,<br>) async {<br>await storage.write(<br>key: &#39;access_token&#39;,<br>value: accessToken,<br>);<br>await storage.write(<br>key: &#39;refresh_token&#39;,<br>value: refreshToken,<br>);<br>}<br>// Read the Access Token<br>Future&lt;String?&gt; getAccessToken() async {<br>return await storage.read(key: &#39;access_token&#39;);<br>}<br>// Read the Refresh Token<br>Future&lt;String?&gt; getRefreshToken() async {<br>return await storage.read(key: &#39;refresh_token&#39;);<br>}<br>// Delete tokens on logout<br>Future&lt;void&gt; deleteTokens() async {<br>await storage.delete(key: &#39;access_token&#39;);<br>await storage.delete(key: &#39;refresh_token&#39;);<br>}</pre><h3>Sending the Token to the Server</h3><p>For API requests, the token is passed in the <strong>Authorization</strong> header.</p><p>Here is a client-side example using Dio:</p><pre>import &#39;package:dio/dio.dart&#39;;<br>final dio = Dio();<br>Future&lt;void&gt; sendToken(String token) async {<br>final response = await dio.get(<br>&#39;https://example.com/api&#39;,<br>options: Options(<br>headers: {<br>&#39;Authorization&#39;: &#39;Bearer $token&#39;,<br>},<br>),<br>);<br>print(response.data);<br>}</pre><p>In a production application, token refresh logic is usually more involved. The client needs to obtain the Refresh Token, send it to the server, save the new token pair, and then retry the original request that resulted in a 401 response.</p><p>That is the foundation of JWT authentication in Flutter. There are, of course, more edge cases and implementation details to consider, but this is enough to get started.</p><p>How do you implement JWT authentication in your Flutter projects? Share your approach in the comments.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=295f611884e1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How State Works in Flutter: Local State, App State, InheritedWidget, and Provider]]></title>
            <link>https://friflex.medium.com/how-state-works-in-flutter-local-state-app-state-inheritedwidget-and-provider-b6b0d17ceef2?source=rss-a7582099fee5------2</link>
            <guid isPermaLink="false">https://medium.com/p/b6b0d17ceef2</guid>
            <dc:creator><![CDATA[Friflex]]></dc:creator>
            <pubDate>Thu, 13 Aug 2026 10:24:20 GMT</pubDate>
            <atom:updated>2026-08-13T10:24:20.381Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-gA4t18FI44bfNrGJ2M_ag.png" /></figure><p>Hi, Medium! We’re Anya, Flutter Team Lead at Friflex, and Katya, a Flutter Developer at Friflex.</p><p>In this article, we’ll explore what state means in Flutter. Katya will explain the difference between local state and app state and when setState() is all you need. Anya will show how to pass data down the widget tree with InheritedWidget and take a closer look at how Provider works.</p><h3>What Is State?</h3><p>In the broadest sense, state is everything stored in an app’s memory while it is running: fonts, textures, animations, UI elements, variables, and more.</p><p>But we don’t manage all of it ourselves. Flutter, for example, handles textures internally. For us, a more useful definition is this: state is the data that the UI depends on, and changes to that data may cause the UI to rebuild.</p><p>The state we manage in a Flutter app can generally be divided into two types: ephemeral state and app state.</p><h3>What Is Ephemeral State?</h3><p>Ephemeral state is also known as local state. The name captures its purpose quite well: this type of state belongs to a single widget and does not need to exist outside that widget’s context. Its lifecycle is tied to the widget itself.</p><p>Examples include:</p><ul><li>the current page in a PageView;</li><li>the selected tab in a BottomNavigationBar;</li><li>animation progress.</li></ul><p>There is usually no need to persist this type of state between sessions or share it across the app. It changes locally.</p><p>The simplest way to implement ephemeral state is with a StatefulWidget and the setState() method.</p><p>Let’s look at a simple example: a custom text field with a clear button that should appear when the field contains text. We’ll create a StatefulWidget called CustomTextField. Its State might look like this:</p><pre><br>class _CustomTextFieldState extends State&lt;CustomTextField&gt; {<br>  late final TextEditingController controller;<br><br>  bool showClearButton = false;<br><br>  @override<br>  void initState() {<br>    super.initState();<br><br>    controller = TextEditingController();<br><br>    controller.addListener(<br>      () =&gt; setState(() =&gt; showClearButton = controller.text.isNotEmpty),<br>    );<br>  }<br><br>  @override<br>  Widget build(BuildContext context) {<br>    return TextField(<br>      controller: controller,<br>      decoration: InputDecoration(<br>        suffixIcon: showClearButton<br>            ? IconButton(<br>                icon: const Icon(Icons.clear),<br>                onPressed: () {<br>                  controller.clear();<br><br>                  setState(() {<br>                    showClearButton = false;<br>                  });<br>                },<br>              )<br>            : null,<br>      ),<br>    );<br>  }<br><br>  @override<br>  void dispose() {<br>    controller.dispose();<br>    super.dispose();<br>  }<br>}</pre><p>This is a straightforward example of ephemeral state.</p><p>Here is another example using BottomNavigationBar:</p><pre>class MyHomepage extends StatefulWidget {<br>const MyHomepage({super.key});<br>@override<br>State&lt;MyHomepage&gt; createState() =&gt; _MyHomepageState();<br>}<br>class _MyHomepageState extends State&lt;MyHomepage&gt; {<br>int _index = 0;<br>@override<br>Widget build(BuildContext context) {<br>return BottomNavigationBar(<br>currentIndex: _index,<br>onTap: (newIndex) {<br>setState(() {<br>_index = newIndex;<br>});<br>},<br>// … items …<br>);<br>}<br>}</pre><p>Here, _index is ephemeral state. It exists only within this screen and can safely be reset when the app restarts.</p><h3>What Is App State?</h3><p>App state is state that affects multiple widgets. It may also be shared across different parts of the app, such as multiple screens.</p><p>App state is also known as shared state. It includes data that multiple screens or parts of the app need and may be involved in core business logic. When necessary, the app can also persist this state between user sessions.</p><p>Examples include:</p><ul><li>user data such as a login or token;</li><li>settings and preferences;</li><li>a shopping cart in an e-commerce app;</li><li>notifications or a list of unread articles.</li></ul><p>A shopping cart is a classic example.</p><p>An e-commerce app will usually have a cart page where users can see previously added items, manage them, and place an order. But the cart may also affect other parts of the app. For example, the product catalog may indicate which items have already been added to the cart, and the same information may be relevant on a favorites page.</p><p>State like this is often managed with state management solutions such as BLoC or Redux.</p><p>Common tools for managing app state include:</p><ul><li>Provider / Riverpod — for declarative state management;</li><li>Redux / BLoC — for more complex applications;</li><li>Hive / SharedPreferences — for persisting data to disk.</li></ul><p>It is important to understand that the boundary between ephemeral state and app state is not absolute.</p><p>For example, the selected tab in a BottomNavigationBar may be ephemeral if it matters only within a single screen. But it can become app state if the app needs to restore the selected tab when the user returns and if that value affects other parts of the app.</p><p>Redux co-author Dan Abramov once gave a useful rule of thumb: “Do whatever is less awkward.”</p><p>Depending on the goals and requirements of your project, either type of state may be appropriate. A useful principle is to start small and scale up when necessary.</p><p>In practice, it often makes sense to begin with ephemeral state and move state higher up or make it global only when there is a clear need. Too much global state can significantly complicate an app’s architecture and introduce dependencies that become difficult to manage over time.</p><h3>What Is InheritedWidget and How Does It Work?</h3><p>InheritedWidget is a widget that makes data available to descendant widgets further down the widget tree without requiring you to pass that data through constructors.</p><p>For example, let’s create a CustomInherited widget:</p><pre>class CustomInherited extends InheritedWidget {<br>const CustomInherited({<br>required this.data,<br>required Widget child,<br>}) : super(child: child);<br>final String data;<br>static CustomInherited? of(BuildContext context) =&gt;<br>context.dependOnInheritedWidgetOfExactType&lt;CustomInherited&gt;();<br>@override<br>bool updateShouldNotify(CustomInherited oldWidget) =&gt;<br>data != oldWidget.data;<br>}</pre><p>CustomInherited implements a static of(context) method. Under the hood, this method calls context.dependOnInheritedWidgetOfExactType&lt;T&gt;(), which searches the widget tree using the provided context, finds the nearest CustomInherited instance, and returns it.</p><p>Now CustomInherited is ready to be added to the widget tree:</p><pre>CustomInherited(<br>  data: &#39;inherited data&#39;,<br>  child: Builder(<br>    builder: (context) {<br>      return Container(<br>        padding: const EdgeInsets.all(16),<br>        child: Text(CustomInherited.of(context)?.data ?? &#39;&#39;),<br>      );<br>    },<br>  ),<br>)</pre><p>Because InheritedWidget exposes data through the widget tree, it must be placed above the widgets that need access to that data. In this example, the Text widget needs the string stored in CustomInherited, so CustomInherited is placed above it in the tree.</p><p>When appropriate, the official Flutter documentation recommends implementing two methods: maybeOf(context) and of(context). The first returns a nullable instance, while the second returns a non-nullable one.</p><pre>static CustomInherited? maybeOf(BuildContext context) {<br>return context.dependOnInheritedWidgetOfExactType&lt;CustomInherited&gt;();<br>}<br>static CustomInherited of(BuildContext context) {<br>final result = maybeOf(context);<br>assert(result != null, &#39;No CustomInherited found in context&#39;);<br>return result!;<br>}</pre><p>InheritedWidget also requires us to override updateShouldNotify. This method returns a bool and determines whether dependent widgets should be notified when the InheritedWidget is updated.</p><h3>What Is Provider and How Does It Work?</h3><p>The <a href="https://pub.dev/packages/provider">provider</a> package is one of the best-known libraries in the Flutter community. Provider is built on top of InheritedWidgetand offers a more convenient API for dependency injection and state management.</p><p>The key point is that Provider follows the same basic principle as InheritedWidget: data is made available down the widget tree and can then be accessed through BuildContext.</p><h3>Providing Data</h3><p><a href="https://pub.dev/documentation/provider/latest/provider/Provider-class.html">Provider</a> makes it convenient to expose data to widgets further down the tree. Just like InheritedWidget, it needs to be placed above the widgets that will use that data.</p><p>There are two ways to do this.</p><h4>Using the Standard Provider() Constructor</h4><p>With the standard constructor, the data source is created using the create callback.</p><pre>Provider(<br>create: (context) =&gt; CustomData(),<br>child: Container(),<br>)</pre><h4>Using Provider.value()</h4><p>This constructor does not create a new data source. Instead, it receives an existing instance.</p><pre>final customData = CustomData();<br>Provider.value(<br>value: customData,<br>child: Container(),<br>)</pre><p>If you need to provide several data sources at once, you can use <a href="https://pub.dev/documentation/provider/latest/provider/MultiProvider-class.html">MultiProvider</a>.</p><p>The library also includes several other provider types, such as <a href="https://pub.dev/documentation/provider/latest/provider/StreamProvider-class.html">StreamProvider</a> and <a href="https://pub.dev/documentation/provider/latest/provider/FutureProvider-class.html">FutureProvider</a>.</p><h3>Reading Data</h3><p>Further down the widget tree, we can access the provided data through BuildContext. There are three main methods for doing this:</p><ol><li>context.read&lt;T&gt;() — gets the current value without subscribing to changes.</li><li>context.watch&lt;T&gt;() — subscribes to changes and rebuilds the current widget when the value changes.</li><li>context.select&lt;T, R&gt;(R cb(T value)) — subscribes only to a selected part of the data, such as a single field.</li></ol><p>The library also provides the <a href="https://pub.dev/documentation/provider/latest/provider/Consumer-class.html">Consumer</a> and <a href="https://pub.dev/documentation/provider/latest/provider/Selector-class.html">Selector</a> widgets. Like context.watch and context.select, they listen for changes in provider data, but they allow you to rebuild only a specific child widget rather than the entire current widget.</p><pre>class Example extends StatelessWidget {<br>const Example({super.key});<br>@override<br>Widget build(BuildContext context) {<br>return Column(<br>children: [<br>const Text(&#39;Line 1&#39;),<br>Text(context.watch&lt;CustomData&gt;().data),<br>// Rebuilds the entire Example widget<br>const Text(&#39;Line 3&#39;),<br>],<br>);<br>}<br>}<br>class Example2 extends StatelessWidget {<br>const Example2({super.key});<br>@override<br>Widget build(BuildContext context) {<br>return Column(<br>children: [<br>const Text(&#39;Line 1&#39;),<br>Consumer&lt;CustomData&gt;(<br>// Rebuilds only the child Text widget<br>builder: (context, customData, _) {<br>return Text(customData.data);<br>},<br>),<br>const Text(&#39;Line 3&#39;),<br>],<br>);<br>}<br>}</pre><p>You can find more useful information in the library’s <a href="https://pub.dev/documentation/provider/latest/provider/">class documentation</a> and its <a href="https://github.com/rrousselGit/provider/tree/master/packages/provider#readme">README</a>.</p><p>What tells you that a local setState() is no longer enough and that it is time to move state higher up the widget tree or extract it into a dedicated state management solution?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b6b0d17ceef2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to Add Your Own Extension to DevTools and Interact with Application Code]]></title>
            <link>https://friflex.medium.com/how-to-add-your-own-extension-to-devtools-and-interact-with-application-code-083385144e25?source=rss-a7582099fee5------2</link>
            <guid isPermaLink="false">https://medium.com/p/083385144e25</guid>
            <category><![CDATA[provider]]></category>
            <category><![CDATA[devtools]]></category>
            <category><![CDATA[development]]></category>
            <category><![CDATA[flutter]]></category>
            <category><![CDATA[state]]></category>
            <dc:creator><![CDATA[Friflex]]></dc:creator>
            <pubDate>Thu, 30 Jul 2026 14:23:29 GMT</pubDate>
            <atom:updated>2026-07-30T14:23:29.410Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Py2tB1cZD56HtKFIH-RxVA.png" /></figure><p>Hi, Medium! I’m Roza, a Flutter developer at Friflex. I’m sure many of you are familiar with Dart DevTools and have already used it to analyze your Flutter applications. But have you ever tried building your own extensions? I recently had to create one, and I’d like to share what I learned along the way.</p><h3>Getting started</h3><p>First, create a new package for the extension. You can do this with the following command:</p><p>flutter create — template app — platforms web my_dev_tools_ext</p><p>There is no official template for DevTools extensions, so you need to set up the required structure manually.</p><p>Next, add the devtools_extensions package. It provides the tools you need to build a custom extension, including access to the virtual machine, themes, widgets, and other DevTools features.</p><p>For example, it gives you access to the following managers:</p><ul><li>extensionManager — interaction with DevTools;</li><li>serviceManager — access to the VM, if connected;</li><li>dtdManager — communication with the Dart Tooling Daemon.</li></ul><p>Create a devtools directory at the root of the package, then add a build directory inside it. You will also need a config.yamlconfiguration file.</p><pre>my_dev_tools_ext/<br>extension/<br>devtools/<br>build/<br>config.yaml<br>lib/<br>src/<br>…</pre><p>The config.yaml file:</p><pre>&#39;&#39;&#39;yaml<br>name: my_dev_tools_ext<br>issueTracker: https://...<br>version: 0.0.1<br>materialIconCodePoint: &#39;0xe0b1&#39;<br>requiresConnection: false<br>&#39;&#39;&#39;</pre><p>Here is what the fields mean:</p><p>name: the name of the package associated with the DevTools extension. This value is used to identify the extension in DevTools.</p><p>issueTracker: the URL of the extension’s issue tracker. When a user clicks Report an issue in the DevTools interface, they are redirected to this URL.</p><p>version: the version of the DevTools extension. This value is displayed in the extension page header.</p><p>materialIconCodePoint: the icon used for the extension tab in the top-level DevTools tab bar.</p><p>Optional fields:</p><p>requiresConnection: specifies whether the extension requires a connected Dart or Flutter app to run. The default value is false.</p><p>In this article, I focus on practical experience rather than covering every feature available in the package. If you plan to use DevTools extensions in your work, be sure to check the documentation as well. It describes additional APIs and scenarios that may be useful in more complex cases.</p><p>Now let’s build the UI. In addition to devtools_extensions, the devtools_app_shared package is particularly useful. It contains ready-made components and utilities used in the original DevTools interface.</p><p>Here is an example using a button:</p><pre>DevToolsButton(<br>  onPressed: () async {<br>    await someService.saveData();<br>    extensionManager.showNotification(&#39;Data saved successfully!&#39;);<br>  },<br>  icon: Icons.save,<br>  label: &#39;Save&#39;,<br>)</pre><p>extensionManager.showNotification displays a notification. In a simulated environment, it appears as a console log.</p><h3>Connecting and testing the extension</h3><p>Add a DevToolsExtension wrapper to initialize the extension:</p><pre>void main() {<br>  runApp(const LocalizationDevToolsExtension());<br>}<br><br>class LocalizationDevToolsExtension extends StatelessWidget {<br>  const LocalizationDevToolsExtension({super.key});<br><br>  @override<br>  Widget build(BuildContext context) {<br>    return const DevToolsExtension(<br>      child: LocalizationSnapshotterWidget(), // Your main widget<br>    );<br>  }<br>}</pre><p>You can test the extension in a simulated environment. Run the following command from the root of the extension package:</p><pre>flutter run -d chrome - dart-define=use_simulated_environment=true</pre><p>Once everything works correctly, build the extension:</p><pre>dart run devtools_extensions build_and_copy - source=. - dest=../extension/devtools</pre><p>This creates a build in devtools/build/ that is ready for publication or local use.</p><p>To check whether the extension is configured correctly and can be loaded by DevTools, use the validate command.</p><p>It checks the package structure and verifies that all required files are present.</p><pre>dart run devtools_extensions validate - package=../my_dev_tools_ext</pre><p>This is especially useful when the extension does not appear in DevTools.</p><h3>How DevTools extensions work</h3><p>The basic idea is simple: an extension is a regular Dart package. You can embed it in another pub package or distribute it as a separate package. For the extension to appear in the DevTools interface, it must be added as a dependency of the project in which DevTools is being used.</p><h3>What types of tools can you build?</h3><p>Flutter DevTools extensions can be used to create different types of tools:</p><ul><li>supporting tools for existing packages, such as debugging tools or state visualizations;</li><li>standalone tools distributed as separate packages;</li><li>tools that communicate with a running app through the VM Service;</li><li>tools that do not require a connection to an app, such as configuration or data analysis tools;</li><li>tools that work with project files through an IDE integration.</li></ul><h3>Types of DevTools extensions</h3><p>Flutter DevTools supports two main types of extensions: standalone extensions and companion extensions.</p><h4>Standalone extensions</h4><p>Standalone extensions are developed as separate packages and are not tied to an existing pub package.</p><p>The extension source code can be stored in the same repository as the main project and added as a dev_dependency.</p><p>I described how to create a standalone extension above.</p><h4>Companion extensions</h4><p>Companion extensions are distributed as part of an existing pub package.</p><p>When a user adds such a package to their app, DevTools automatically discovers the extension and adds a new tab for it.</p><p>In practice, the choice between a standalone and companion extension depends on how closely the extension is connected to your package. A standalone extension is generally a better fit for an auxiliary development tool, while a companion extension works well when it forms part of the package’s overall developer experience.</p><p>Next, I’ll explain how to create a companion extension.</p><h3>Embedding an extension in an existing pub package</h3><p>Suppose you already have a package with implemented functionality and want to build a DevTools extension for it. Creating a separate dependency solely for the extension may be unnecessary. In this case, it is easier to make the extension part of the existing package.</p><p>For example, when a user adds package:some_package to their app, they automatically gain access to the DevTools extension embedded in that package. When DevTools starts, it detects the extension and adds a new tab for it.</p><p>How do you set this up? The process is straightforward. In the Dart package that provides the DevTools extension, add an extension directory at the top level:</p><pre>some_package/  <br> extension/  <br> lib/  <br> ...</pre><p>The extension directory should have the following structure:</p><pre>extension/<br> devtools/<br>   build/<br>   config.yaml</pre><p>The resulting project structure will look something like this:</p><pre>some_app/  <br> packages/<br>  some_package/  <br>     extension/<br>      devtools/<br>        build/<br>          ...  <br>         config.yaml<br>  some_devtools_extension/<br>    lib/</pre><p>If the functionality of the extension is unrelated to the functionality of the package itself, combining them may make the architecture harder to understand. In that case, it is better to move the extension into a separate pub package and add it as a dev_dependency.</p><p>If the extension is intended for one project only and should remain self-contained, you can keep it in the same repository as the main package while making it a separate module. This simplifies development, and adding it through dev_dependencydoes not affect the size of the final user-facing application.</p><h3>What is EvalOnDartLibrary?</h3><p>EvalOnDartLibrary is a class from the devtools_app_shared package that allows you to execute Dart code directly from a DevTools extension. You can use it to manage application state, call methods, and retrieve runtime values.</p><p>I found this tool quite surprising. At first, I did not realize that a DevTools extension could interact with an app at such a deep level.</p><h3>How it works</h3><p>To use EvalOnDartLibrary, you first need to initialize it and provide everything required to work with vmService.</p><pre>Future&lt;void&gt; initEval() async {<br>  await serviceManager.onServiceAvailable;<br>  _controllerEval = EvalOnDartLibrary(<br>    &#39;package:some_package/src/controller.dart&#39;, // Path to the library containing the required code<br>    serviceManager.service!,                    // Pass vmService. Make sure serviceManager.service is not null after onServiceAvailable<br>    serviceManager: serviceManager,<br>  );<br>  evalDisposable = Disposable(); // Be sure to create a Disposable<br>}</pre><p>serviceManager.service! is an instance of VmService.</p><p>Disposable is required to manage the lifecycle correctly and prevent unnecessary subscriptions or calls from remaining active after DevTools is closed.</p><p>Make sure that serviceManager.service is not null after onServiceAvailable.</p><h3>EvalOnDartLibrary methods</h3><p>EvalOnDartLibrary provides the following methods:</p><ul><li>asyncEval — executes code asynchronously;</li><li>eval — evaluates an expression;</li><li>evalInstance — retrieves an object instance so you can work with its fields and methods;</li><li>safeEval — a safer wrapper around eval that also handles execution errors.</li></ul><p>In practice, you can first perform an action and then retrieve its result separately from the runtime. For example, you can call a method and then read the resulting value.</p><p>Both eval and asyncEval limit the amount of data that can be returned. It is therefore often more convenient to call a method through asyncEval or eval, then retrieve the required value through evalInstance.</p><p>Here is an example:</p><pre>Future&lt;String?&gt; _getValue() async {<br>  await _controllerEval.asyncEval(<br>    &#39;await SomeController.instance.calculateValue()&#39;, // Run an asynchronous function<br>    isAlive: evalDisposable,<br>  );<br><br>  final result = await _controllerEval.evalInstance(<br>    &#39;SomeController.instance.sum.value&#39;, // Retrieve the value after execution<br>    isAlive: evalDisposable,<br>  ); // The result is an object of type Instance<br><br>  return result?.valueAsString; // Return the value as a string<br>}</pre><p>The asynchronous calculateValue() method is called first. The updated value of SomeController.instance.sum.value is then read from the runtime.</p><p>It is also important to remember to pass isAlive: evalDisposable.</p><h3>Working with EvalOnDartLibrary</h3><p>There are several important details to consider when working with EvalOnDartLibrary.</p><p>The code runs in the context of the current isolate, so access to objects and libraries is limited to what has actually been loaded at runtime.</p><p>This can lead to several complications:</p><ul><li>code may be unavailable because of tree shaking;</li><li>private classes and fields may not always be accessible;</li><li>deferred imports may introduce additional limitations.</li></ul><h3>What is Instance?</h3><p>The evalInstance method returns an Instance, which is a reference to the result of the executed code.</p><p>You can then convert this value, for example, to a string using valueAsString. However, not every value should automatically be converted to a string. Depending on the result, additional checks may be required.</p><p>For example:</p><pre>final result = await _controllerEval.evalInstance(<br>&#39;SomeController.instance.sum.value.toString()&#39;,<br>isAlive: evalDisposable,<br>);<br>final value = result?.valueAsString;</pre><h3>Rules for working with EvalOnDartLibrary</h3><p>In practice, these are the kinds of details that determine whether everything starts working quickly or suddenly breaks at the worst possible moment.</p><ol><li>Use Disposable to manage the lifecycle.</li><li>Keep the result size limit in mind.</li><li>Pass only valid Dart expressions.</li><li>Remember to update the paths used by EvalOnDartLibrary when the project structure changes.</li></ol><h3>Conclusion</h3><p>Working with DevTools was a valuable experience for me. I had no idea it could be used this way.</p><p>You can also use serviceManager to retrieve app code using an isolate ID, although that comes with its own set of nuances. I’ll cover them another time.</p><p>Have you ever built your own DevTools extensions? Share your experience in the comments!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=083385144e25" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How We Speed Up Flutter Development in VS Code: Extensions and Keyboard Shortcuts]]></title>
            <link>https://friflex.medium.com/how-we-speed-up-flutter-development-in-vs-code-extensions-and-keyboard-shortcuts-1ba0ae27bb90?source=rss-a7582099fee5------2</link>
            <guid isPermaLink="false">https://medium.com/p/1ba0ae27bb90</guid>
            <category><![CDATA[mobile-app-development]]></category>
            <category><![CDATA[vc-code]]></category>
            <category><![CDATA[flutter-app-development]]></category>
            <category><![CDATA[flutter]]></category>
            <dc:creator><![CDATA[Friflex]]></dc:creator>
            <pubDate>Wed, 15 Jul 2026 07:25:41 GMT</pubDate>
            <atom:updated>2026-07-15T07:25:41.215Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*d_avfUgZjhD10D7-_QAZcQ.png" /></figure><p>Hello, Medium! We’re Anna, Flutter Team Lead at Friflex, and Rosa, a Flutter Developer at Friflex.</p><p>In this article, we’ll share how we reduce routine work in VS Code. We’ll cover useful extensions and keyboard shortcuts that help us search, edit, and navigate code faster.</p><h3>VS Code extensions that help reduce routine work</h3><h4><a href="https://marketplace.visualstudio.com/items?itemName=alexisvt.flutter-snippets">Flutter Widget Snippets</a></h4><p>Snippets in VS Code are a convenient way to quickly generate common and repetitive pieces of code. This extension lets you create many of the most popular Flutter widgets in just a few keystrokes, including StatelessWidget, StatefulWidget, and layout widgets.</p><p>It also includes Dart snippets for quickly creating classes, methods, and variables. Snippets can noticeably speed up development. However, beginners should first get comfortable with Flutter syntax and learn to write code without relying too heavily on additional tools.</p><h4><a href="https://marketplace.visualstudio.com/items?itemName=FelixAngelov.bloc">bloc</a></h4><p>If you use the bloc library in Flutter projects, this extension can become an essential helper. It includes snippets that make it easier to add widgets to the UI, create blocs and cubits, and work with their methods.</p><p>The extension also lets you quickly wrap widgets in other library widgets through the context menu. In addition, it can generate entire directories with initial connections between Bloc, State, and Event classes already set up. A useful tool for anyone who does not want to spend extra time organizing files and classes.</p><h4><a href="https://marketplace.visualstudio.com/items?itemName=marcelovelasquez.flutter-tree">Flutter Tree</a></h4><p>Another helpful extension for experienced Flutter developers. It makes it easier to create nested widget structures without manually typing parameters and brackets.</p><p>For example, to create a container with a row of widgets inside, you can write:</p><p><em>Container&gt;Row[Expanded&gt;Text,ElevatedButton&gt;Text]</em></p><p>Press Enter, and Flutter Tree will generate the widget tree for you.</p><h4><a href="https://marketplace.visualstudio.com/items?itemName=streetsidesoftware.code-spell-checker">Code Spell Checker</a></h4><p>This extension is useful for anyone who works in VS Code, not just Flutter developers. It checks spelling in your code, documentation, and object names.</p><p>The extension highlights misspelled words and suggests replacements. If a word is correct, you can add it to exceptions for a specific project or for your user profile. It supports many languages, including Russian.</p><h4><a href="https://marketplace.visualstudio.com/items?itemName=adam-bender.commit-message-editor">Commit Message Editor</a></h4><p>Most serious projects require a clear and consistent commit history that follows a commit convention. Each commit message should reflect the purpose of the change, its type, the files affected, and its importance.</p><p>Commit Message Editor makes it easier to format commits according to these rules. The extension provides a form to fill in, then automatically formats the text and inserts it into the commit message field.</p><h3>How to create your own snippets</h3><p>Sometimes snippets created by other developers are not enough. For example, you may want to optimize repetitive code that is specific to your project or company. In that case, custom snippets can help.</p><p>In VS Code, open <strong>Preferences</strong> and select <strong>Configure Snippets</strong>. You can create either global or local snippets for a specific project.</p><p>After choosing an option, VS Code will open a JSON file where you can add your own snippets. It is important to follow the required structure:</p><pre>&quot;Example Snippet&quot;: {<br>&quot;prefix&quot;: [<br>&quot;sw&quot;<br>],<br>&quot;description&quot;: &quot;Snippet description&quot;,<br>&quot;body&quot;: []<br>}</pre><p>Here, the key is the name of the snippet, and the value contains its configuration. Inside it, there are several fields:</p><ul><li>prefix is the snippet trigger. It can be a string or a list of strings.</li><li>description is a short description of the snippet.</li><li>body is the code that the snippet generates.</li></ul><p>To make snippets more flexible, you can use not only text in the body field, but also special placeholders:</p><ul><li>$1, $2, and so on are tab stops. You can move between them with Tab. A single position can appear multiple times in the body, and its value will be updated everywhere at once.</li><li>${1:PlaceholderText} is a tab stop with default text.</li><li>${2|Container,Column,…|} is a tab stop with a list of available options.</li><li>$0 is the final cursor position.</li></ul><p>There are also variables that insert context-based values:</p><ul><li>$CLIPBOARD inserts text from the clipboard.</li><li>$LINE_COMMENT adds a line comment.</li><li>$BLOCK_COMMENT_START and $BLOCK_COMMENT_END mark the beginning and end of a block comment.</li><li>$TM_FILENAME and $TM_FILEPATH insert the current file name and path.</li></ul><p>Here is an example of a widget snippet:</p><pre>&quot;Example Widget Snippet&quot;: {<br>&quot;prefix&quot;: [<br>&quot;wid&quot;,<br>&quot;example&quot;<br>],<br>&quot;description&quot;: &quot;Simple StatelessWidget&quot;,<br>&quot;body&quot;: [<br>&quot;$LINE_COMMENT $TM_FILENAME - $CURRENT_DATE.$CURRENT_MONTH.$CURRENT_YEAR&quot;,<br>&quot;&quot;,<br>&quot;class ${1:MyWidget} extends StatelessWidget {&quot;,<br>&quot; const ${1:MyWidget}({super.key});&quot;,<br>&quot;&quot;,<br>&quot; @override&quot;,<br>&quot; Widget build(BuildContext context) {&quot;,<br>&quot; return ${2|Container,Column,Row,Scaffold|}(&quot;,<br>&quot; child: Text(&#39;${3:Hello}&#39;),&quot;,<br>&quot; );&quot;,<br>&quot; }&quot;,<br>&quot; $0&quot;,<br>&quot;}&quot;<br>]<br>}</pre><h3>When extensions are not enough: keyboard shortcuts</h3><p>Many developers barely use keyboard shortcuts at the beginning, especially when there is a mouse nearby. But shortcuts can make the development process much faster. Here are the ones we use most often.</p><h4>Navigation and search</h4><ul><li>⌘ + P — open a file by name</li><li>⌘ + Shift + F — search across the entire project</li><li>⌘ + G — go to a line</li><li>⌘ + Shift + O — go to a function or symbol in the current file</li></ul><h4>Code editing</h4><ul><li>Control + Space — trigger autocomplete</li><li>⌘ + / — comment or uncomment a line</li><li>Option + ↑/↓ — move a line up or down</li><li>Shift + Option + ↑/↓ — copy a line up or down</li><li>⌘ + Shift + K — delete a line</li><li>Shift + Option + F — format the document</li><li>Option + Click — add another cursor</li><li>⌘ + Shift + L — select all occurrences of a word</li><li>⌘ + F, then ⌘ + Option + Enter — quick replace</li></ul><h4>Multiple cursors and selections</h4><ul><li>Option + Click — add a cursor at the clicked position</li><li>⌥⌘ + ↑/↓ — add a cursor above or below</li><li>⌘ + U — undo the last cursor action</li><li>⇧⌥ + I — insert a cursor at the end of every selected line</li><li>⌘ + L — select the current line</li><li>⇧⌘ + L — select all occurrences of the current selection</li><li>⌘ + F2 — select all occurrences of the current word</li><li>Control + ⇧⌘ + →/← — expand or shrink the selection</li></ul><h4>Box selection</h4><ul><li>⇧⌥ + drag — select text in a rectangular area</li><li>⇧⌥⌘ + ↑/↓/←/→ — extend the selection up, down, left, or right</li><li>⇧⌥⌘ + PgUp/PgDn — extend the vertical selection by page</li></ul><p>You can customize shortcuts and see the full list in <strong>Code → Settings → Keyboard Shortcuts</strong>, or press ⌘ + K, then ⌘ + S.</p><p>And one final way to make routine work a little more enjoyable: <a href="https://marketplace.visualstudio.com/items?itemName=tonybaloney.vscode-pets">install</a> a virtual pet extension for VS Code, so a cute companion can keep an eye on your work.</p><p>What are your favorite ways to reduce routine work and speed up development? Share them in the comments!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1ba0ae27bb90" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Unconventional Uses of LLMs and Synthetic Data: From Factory “Antivirus” to Data Compression with…]]></title>
            <link>https://friflex.medium.com/unconventional-uses-of-llms-and-synthetic-data-from-factory-antivirus-to-data-compression-with-c012516df895?source=rss-a7582099fee5------2</link>
            <guid isPermaLink="false">https://medium.com/p/c012516df895</guid>
            <category><![CDATA[synthetic-data-generation]]></category>
            <category><![CDATA[llm-agent]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[synthetic-data]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Friflex]]></dc:creator>
            <pubDate>Wed, 15 Apr 2026 15:57:49 GMT</pubDate>
            <atom:updated>2026-04-15T15:57:49.058Z</atom:updated>
            <content:encoded><![CDATA[<h3>Unconventional Uses of LLMs and Synthetic Data: From Factory “Antivirus” to Data Compression with Language Models</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QH5qplFIEvkm0eRl2Hc8Lw.jpeg" /></figure><p>Hi, Medium! My name is Vadim Kondaratsev. I lead the AI division at Friflex and run a small AI lab at Bauman Moscow State Technical University. For the past 10 years, I’ve been working at the intersection of ML, HPC, and edge computing, teaching machine learning and launching something on a supercomputer roughly once a day.</p><p>This is an extended version of my CrossConf 2025 talk about my experience using synthetic data in projects involving machine learning systems in industry and science. If you’re curious about what synthetic data can look like and what problems it can solve, read on.</p><h3>Synthetic Data Is Its Own Engineering Discipline</h3><p>Synthetic data refers to data generated artificially for training and testing ML models. It’s important not to confuse it with augmentation: augmentation transforms existing samples (flip, crop, color jitter), while synthetic data creates fundamentally new ones.</p><p>Generation methods vary drastically, and your choice of method determines the properties of the resulting dataset.</p><p>The reason synthetic data exists is simple: real data is often scarce. It can be expensive, rare, or dangerous to obtain. For example, training an autonomous driving system would require examples of collisions with pedestrians, but no one is going to collect such a dataset. Similarly, detecting accidents in chemical plants requires accident data which, fortunately, is rare.</p><h3><strong>Manual Annotation vs. Render Pass</strong></h3><p>The difference here is fundamental. In tools like CVAT, annotators spend minutes per frame drawing approximate polygons. In contrast, a render pass in Blender or Unity produces perfect masks — every pixel is tied to an object, and the process scales to millions of frames.</p><p>Render passes don’t just provide segmentation masks — they also generate depth maps, normal maps, instance IDs, optical flow, and more, all in parallel and at no additional cost.</p><h3><strong>Case Studies</strong></h3><h4><strong>Factory Antivirus: Kaspersky MLAD</strong></h4><p>This was a joint project with Kaspersky Lab. Their product, MLAD (Machine Learning Anomaly Detection), is essentially an IDS for industrial control systems. It sits between PLCs and operator consoles, detecting anomalies in signal streams.</p><p><strong>Challenge:<br></strong>Training requires examples of attacks and emergency modes, which don’t occur in normal operation. You can’t stage real accidents just to build a dataset.</p><p><strong>Solution:<br></strong>A digital twin of the industrial process. Mathematical models in Dymola and MATLAB Simulink simulate physics: heat transfer, fluid dynamics, chemical kinetics. A real PLC is integrated into the loop.</p><p>Synthetic data here consists of physically accurate time series — temperature, pressure, and flow signals computed from differential equations.</p><p><strong>Results:</strong></p><ul><li>A digital twin with a real PLC in the loop</li><li>Neural models for detecting attacks on PLC traffic</li><li>Software for configuring attack scenarios and collecting training data</li></ul><p><strong>Bonus:<br></strong>The system detects not only malicious attacks but also human errors like a valve left open or a clogged sensor.</p><p><strong>Key insight:<br></strong>In this case, synthetic time series were realistic enough that no real data mixing was required — the neural networks learned directly from the simulator.</p><h4><strong>Drone Inspection for Power Plants</strong></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ORgA-qgNIOUBwz5wyJISrQ.png" /></figure><p><strong>Task:<br></strong>An autonomous drone patrols a thermal power plant, reads analog gauges, and detects defects (steam leaks, corrosion, overheating).</p><p><strong>Initial data:<br></strong>Just 50 (!) photos of defects taken with a flashlight and chalk markings. Completely unusable for training.</p><p><strong>Pipeline highlights:</strong></p><ul><li><strong>HDR environment maps</strong>: 360° HDR panoramas were used in Blender to replicate real lighting conditions (dim lights, reflections, steam).</li><li><strong>LiDAR → Point Cloud → Digital Twin</strong>: A 2-billion-point cloud recreated the entire plant. A virtual drone trained safely inside it.</li></ul><p>For pipe cracks and ruptures, we built Blender scenes with automated drone flight paths and onboard lighting simulation.</p><p><strong>Results:</strong></p><ul><li>Custom synthetic data generators</li><li>LiDAR-based navigation system</li><li>Deep learning models for defect detection</li></ul><p><strong>Challenge:<br></strong>Strong domain shift. Real images had to be heavily augmented and mixed into training. Validation was done strictly on real data.</p><h4><strong>Secure Perimeter: Generative Models for Surveillance</strong></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*19a5QU4kZ_Xx8YM9we1I0g.png" /></figure><p><strong>Task:<br></strong>Detect intrusions, fights, fainting, and fires using CCTV.</p><p>Public datasets don’t match real-world conditions (camera angles, lighting, seasons). A model trained on YouTube fire videos might fail in a snowy parking lot at dusk.</p><p><strong>Approach:<br></strong>Inpainting-based synthetic generation.</p><p>We even asked people to climb fences in winter to gather baseline data. Fire images were generated from real surveillance footage of specific locations.</p><p><strong>Key insight:<br></strong>Generative models don’t understand physics — fire won’t realistically illuminate surroundings, smoke won’t follow wind patterns. That’s fine for bounding-box detection but not for dynamic simulations.</p><h4><strong>Virtual Hydrological Stations</strong></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MpOG9QiJx42sbXoTt8DyKw.png" /></figure><p><strong>Problem:<br></strong>Flood risk prediction relies on hydrological stations, but they may be hundreds of kilometers apart.</p><p><strong>Solution:<br></strong>A geophysical simulation pipeline.</p><p>Input: satellite terrain data<br>Output: a model that predicts water levels at any point from a single image</p><p>Synthetic data here is a full simulation: 3D terrain, hydrodynamics, virtual cameras.</p><p><strong>Results:</strong></p><ul><li>Super-resolution models for satellite imagery</li><li>Water level prediction models</li><li>Automatic river bathymetry models</li><li>Custom satellite data parsers</li></ul><h4>Space Navigation</h4><p>Another case where everything is synthetic — you can’t test satellites against real space debris.</p><p><strong>Task:<br></strong>Help a satellite avoid collisions.</p><p><strong>Solution:<br></strong>A simulator incorporating orbital mechanics and fragmentation models. A reinforcement learning agent plans maneuvers under fuel constraints.</p><p>A VR demo shows what a future mission control station might look like.</p><p><strong>Note:<br></strong>In RL, synthetic environments are the norm even if we don’t explicitly call them “synthetic data.”</p><h3>The Era of LLMs and VLMs</h3><p>From 2018 to 2024, the ML landscape changed dramatically. Large language models (LLMs) and vision-language models (VLMs) introduced entirely new ways to work with data including synthetic data.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-N5kAND0GlgemSPfNYTYng.png" /></figure><h4>LLMs in Design and Manufacturing</h4><p>The paper <a href="https://arxiv.org/abs/2307.14377"><em>How Can Large Language Models Help Humans in Design and Manufacturing?</em></a> (Makatura et al., 2023) outlines how LLMs can be integrated across industrial workflows.</p><h4>LLMs as Compressors: The Most Unexpected Use Case</h4><p>This is probably the most counterintuitive idea.</p><p>The paper <a href="https://arxiv.org/abs/2309.10668"><em>Language Modeling Is Compression</em></a> (Delétang et al., DeepMind, 2023) shows that next-token prediction is mathematically equivalent to data compression.</p><p>A good predictor can be turned into a good compressor (via arithmetic coding) and vice versa.</p><p>The authors demonstrate that LLMs can compress not only text but also images (ImageNet) and audio (LibriSpeech), outperforming traditional domain-agnostic codecs. For serialized data, compression ratios can reach up to 4000×.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wT6QYTDQgB4DdsLVXvPmBA.png" /></figure><h4>Why This Matters for Synthetic Data</h4><p>Compression and generation are two sides of the same coin.</p><p>If a model can compress data well, it has learned the underlying structure and can generate new valid samples.</p><p><strong>Practical takeaway:<br></strong>Instead of building custom synthetic generators for each task, you can fine-tune an LLM on domain data and use it for both generation and validation.</p><h3>Top 5 Tips for Working with Synthetic Data</h3><ol><li><strong>Always mix with real data and validate on real data.<br></strong>Synthetic-only training leads to domain gaps. Even 10–20% real data helps significantly.</li><li><strong>Choose the right type of realism. </strong>Visual → generative models. Physical → simulation/rendering.</li><li><strong>Use synthetic data when real data is expensive, slow, or dangerous to collect.</strong></li><li><strong>Generate data for your specific task.<br></strong>There’s no such thing as a universal data generator.</li><li><strong>Consider semi-automatic labeling.<br></strong>Sometimes pseudo-labeling + manual correction is faster than building a generator.</li></ol><h3>Conclusion</h3><p>Synthetic data isn’t a silver bullet, but it’s an essential engineering tool. Entire domains of ML wouldn’t exist without it: autonomous driving, industrial safety, space navigation, insurance analytics.</p><p>With the rise of LLMs and VLMs, the line between synthetic and real data is blurring even further. A language model trained on domain data becomes both a knowledge compressor and a generator of new examples.</p><p>If you work with synthetic data, feel free to share your experience. I’m especially interested in approaches that combine generative models with classical 3D rendering — what real/synthetic ratios work best for you?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c012516df895" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[8 Interface Design Trends — Without Effects for the Sake of Effects]]></title>
            <link>https://friflex.medium.com/8-interface-design-trends-without-effects-for-the-sake-of-effects-50693793592c?source=rss-a7582099fee5------2</link>
            <guid isPermaLink="false">https://medium.com/p/50693793592c</guid>
            <category><![CDATA[product-design]]></category>
            <category><![CDATA[web-design]]></category>
            <category><![CDATA[design]]></category>
            <category><![CDATA[ux-design]]></category>
            <dc:creator><![CDATA[Friflex]]></dc:creator>
            <pubDate>Thu, 26 Feb 2026 13:35:59 GMT</pubDate>
            <atom:updated>2026-02-26T13:35:59.805Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jrvBraA7nhFJ1jxgagO5lA.png" /></figure><p>Hi! My name is Svetlana Motorkina, and I’m the Head of Design at Friflex. Interface trends appear regularly, but unfortunately, most of them don’t survive real product environments. In this article, I look at interfaces not as a collection of visual tricks, but as a system — from color and shape to accessibility, animation, and new AI-driven scenarios.</p><p>The criterion is simple: does the approach help users solve their task faster, more accurately, and with less stress? And does it stand up to long-term use?</p><h4>Color and Accent Strategy</h4><p>The purpose of color is to help users navigate the interface without causing fatigue during extended use. Overly aggressive palettes quickly exhaust users and make them want to close the app or website. That’s why product interfaces almost always rely on a neutral base. It improves readability and keeps the experience comfortable over time.</p><p>Accent colors are usually limited to one or two. They’re expressive but not loud — and most importantly, used only where there’s an action or an important state. In essence, they serve as navigation cues: where to look and what can be interacted with.</p><p>Light and dark themes are rarely mirror versions of each other. Dark themes typically have higher contrast, fewer color highlights, and fewer decorative elements to reduce eye strain. Differences between themes are more often built on form, density, and lightness, with color supporting hierarchy rather than defining it.</p><p>Context is critical here. The same shade can be perceived differently: in fintech, green is associated with growth and profit; in medtech, it signals calmness and sterility. These associations already exist in users’ minds, so color shouldn’t be chosen abstractly. Even if readability is technically fine, color can create internal dissonance.</p><h4>Glassmorphism</h4><p>The frosted glass effect is now widely used as part of interface systems. But what matters is not the blur itself — it’s how the element works against the background and whether content remains readable.</p><p>A common setup looks like this: a subtle tint overlay in the 8–16% range placed over the background. Hierarchy is defined through layered elevations and shadows tied to the same elevation tokens used for other components. Text placed on glass surfaces is tested against WCAG standards: a contrast ratio of at least 4.5:1 for regular text and 3:1 for large text.</p><h4>Animation</h4><p>As mobile devices have become more powerful, UI animation has stopped being a luxury and effects for the sake of effects have faded away. What matters today is motion that clarifies logic: where an element comes from, where it goes, and which action has been confirmed.</p><p>These are cause-and-effect transitions, micro-animations of states, and well-tuned motion curves.</p><p>Typically, such animations are short and lightweight — around 120–240 milliseconds — with minimal delays. They rely on transform and opacity properties, avoid unnecessary repaints, and respect system preferences like prefers-reduced-motion, ensuring the interface remains comfortable for everyone.</p><h4>3D and Real-Time Preview</h4><p>Three-dimensional interfaces are back — but not everywhere. 3D makes sense when something cannot be clearly represented in a flat diagram or static image. For example, furniture, electronics, or car configurators, maps, and complex visualizations.</p><p>In many other cases, 3D becomes excessive. Alternatives such as static images, GIFs, or flat renders may work just as well.</p><p>3D previews are best loaded on demand or only when the connection is stable. Scenes should remain lightweight: limited polygon counts, basic materials, soft shadows — without heavy post-processing effects. This keeps previews fast and prevents the interface from feeling overloaded.</p><h4>UX Forms</h4><p>Login and registration are often treated as purely technical steps, but in practice, this is where most users drop off. The goal of a form is simple: move the user forward as quickly as possible.</p><p>Modern interfaces prioritize passkeys or magic links, where authentication is confirmed in the browser, on a phone, or via email. Passwords remain a fallback option.</p><p>Input requirements should be shown upfront, and captchas or unnecessary steps should be avoided whenever possible.</p><p>Autofill should be used extensively so browsers and password managers can populate fields automatically. Password visibility toggles are helpful. Errors should appear immediately below the relevant field, and entered data should never be reset — users need to remain in control.</p><h4>Personalization</h4><p>Effective personalization removes friction and immediately surfaces relevant results such as recommendations, similar products, or quick-access lists. Its purpose is not to show more, but to narrow choices down to what matters. To do this, the system considers previous actions, constraints, and user preferences.</p><p>Users may wonder: why am I seeing these recommendations? Personalization feels non-intrusive when its logic is transparent. Short explanations help: “You’ve purchased this before,” “You might like this,” or “Users with similar preferences bought this.”</p><p>It’s equally important to allow users to manage personalization: hide recommendations, reset settings, or adjust results through filters. To avoid confusion, content-related personalization settings should be visually separated from core interface settings.</p><h4>WCAG 3.0 and Accessibility</h4><p>Updates to WCAG directly impact design systems. At the library level, this means revisiting foundational components: buttons, inputs, selects, tabs, menus, modals, and tables. Accessibility must be built in by default, not manually checked on every screen.</p><p>Here are the rules we follow when developing user interfaces:</p><ul><li><strong>Visible focus states.</strong> The outline is not hidden under shadows or glows. A clear indicator with at least a 3:1 contrast ratio against adjacent backgrounds, a minimum thickness of 2px, and a small outline offset to prevent clipping.</li><li><strong>Minimum touch target size:</strong> 24×24 px. If an icon is 16px, padding compensates.</li><li><strong>Full keyboard navigation.</strong> Tab/Shift+Tab, Enter/Space, Esc, and arrow keys work according to established interaction patterns.</li><li><strong>Authentication without captchas.</strong> Use codes, magic links, and “show password” functionality.</li><li><strong>Dragging is not the only option.</strong> Button-based alternatives allow users to move and sort items (“move up/down,” “move to…,” “sort”).</li><li><strong>Contrast ratios:</strong> ≥ 4.5:1 for regular text and ≥ 3:1 for large text (approximately 18pt regular or 14pt bold and above).</li></ul><h4>AI Assistants</h4><p>AI assistants are most commonly used for search, product selection, and routine tasks like filling out long forms. A user might say, “Find a birthday gift,” and the assistant assembles suitable options into the cart.</p><p>The key principle here is transparency. Users can see exactly what the assistant is doing: proposed changes can be reviewed before being applied. At any stage, the process can be stopped and reverted.</p><p>The assistant shows where its data comes from. For sensitive operations such as payments, data deletion, or subscription changes, explicit confirmation is always required. AI can accelerate workflows, but control and responsibility remain with the user.</p><p>What sustainable interface design trends have you noticed? Share your thoughts in the comments.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=50693793592c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Flutter is everywhere (even in your kettle). Part 1]]></title>
            <link>https://friflex.medium.com/flutter-is-everywhere-even-in-your-kettle-part-1-ebfdd4bd73b5?source=rss-a7582099fee5------2</link>
            <guid isPermaLink="false">https://medium.com/p/ebfdd4bd73b5</guid>
            <dc:creator><![CDATA[Friflex]]></dc:creator>
            <pubDate>Fri, 28 Nov 2025 08:39:28 GMT</pubDate>
            <atom:updated>2025-11-28T08:39:28.235Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kvU48U3d9n8f7OxljYK_ag.png" /></figure><p>Hi, Medium! My name is Yura Petrov, I’m the head of development at Friflex. In this article I want to keep talking about Flutter: which platforms it runs on, what its advantages are (and how you can literally make the firmware for your own kettle).</p><h4><strong>Write the code once</strong></h4><p>Flutter has a great slogan: write the code once and run it on iOS, Android, web, Linux, macOS without changing anything in the project.</p><p>Flutter has a few key traits:</p><ul><li>a modern, high-performance, compiled language Dart</li><li>its own rendering engine Impeller</li><li>high performance (if someone tells you Flutter is slow, don’t believe them, that’s complete nonsense)</li><li>a very large community</li></ul><p>Let’s go back to that slogan: write the code once. That’s 100% about Flutter.</p><h4><strong>Platforms Flutter supports</strong></h4><p>Let’s look at the list of officially supported platforms.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xJdbTQxccdN33VFthRgIDA.png" /></figure><p>We’ve got Linux, Windows, macOS, Embedded, web and Android. But what if I told you that’s far from the full list, and there are more players?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DVr5A_MmsYODoIHpwtEGJA.png" /></figure><p>For example: Aurora, Huawei and Tizen (the OS used in Samsung TVs, which is very popular right now). If you dig deeper and really go down the rabbit hole, you’ll find WebOS, Raspberry Pi, ports for Sony devices (Linux-based platforms), and the Yocto Project.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*voJWUE2CZXuQcCdxk3oU9Q.png" /></figure><p>Do you think there’s any other framework today that covers even half of these platforms? Imagine this: Flutter can. You don’t need to change your core code — you can take your Flutter app and roll it out to WebOS, Raspberry Pi, Huawei, Tizen… That’s genuinely impressive.</p><p>You can explore all this at the links below:</p><ul><li>Aurora OS: active fork by OMP <a href="https://gitlab.com/omprussia/flutter/flutter?utm_source=chatgpt.com">gitlab</a></li><li>Tizen (Samsung): active fork by Samsung <a href="https://github.com/flutter-tizen">github</a></li><li>HarmonyOS: active fork by Huawei <a href="https://gitcode.com/openharmony-sig/flutter_flutter">gitee</a></li><li>webOS (LG Smart TV): closed SDK <a href="https://webostv.developer.lge.com/news/2024-07-15-new-and-successful-experiment-of-webos-with-flutter">webos</a></li><li>flutter-pi (Raspberry Pi): active community fork <a href="https://github.com/ardera/flutter-pi">github</a></li><li>Flutter eLinux (Sony): active fork by Sony <a href="https://github.com/sony/flutter-elinux?utm_source=chatgpt.com">github</a></li><li>Yocto (meta-flutter): active community fork <a href="https://github.com/meta-flutter/meta-flutter">github</a></li></ul><h4><strong>A bit more about some of these platforms</strong></h4><p><strong>Aurora.</strong> Latest port version: 3.29.2.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Hn3zQfo8ohNkSJzT1Rnw6w.png" /></figure><p>Notice how close that is to the original Flutter version. That’s actually very good news. All the important plugins like Camera and WebView are already baked into the Flutter SDK you download. You don’t have to worry about anything — it all works out of the box.</p><p>There are also plenty of community plugins, but there’s one caveat: for now, you can’t develop on Macs with M-series processors. The SDK itself already works in a beta version, though, so I think it’s only a matter of time.</p><p><strong>Huawei.</strong> Latest port version: 3.22.2.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2pTixkkKsSZQ1Uc8v9CjSw.png" /></figure><p>What’s interesting is that their plugins are published on PubDev — you can just download and use them. You can check them out <a href="https://pub.dev/publishers/harmonycandies.com/packages">there</a>.</p><p>On top of that, there are lots of community plugins. You won’t really find them in regular search engines, but if you search through Qwen or DeepSeek, for example, you’ll stumble on a ton of forums and sites where various plugins and packages are being developed.</p><h4>Yocto Project</h4><p>Okay, let’s get back to our Flutter-powered kettle. This is where I suggest we talk about the Yocto Project, because that’s exactly what you’d use to build such a kettle.</p><p>Yocto Project is a set of tools for building your own Linux system — essentially firmware for almost any device. Think of it as Lego for Linux.</p><p>Say you’re building some device (a kettle or a fridge, it doesn’t matter) and you want Flutter to run on it.<br>In practice, it’s not that hard:</p><ul><li>you pick your hardware: ARM, Wi-Fi, GPU</li><li>build the Flutter Engine for that device and write your app in Flutter</li><li>compile the firmware and flash your kettle</li></ul><p>Voilà — you’ve got a kettle running a Flutter skeleton.</p><h4>Why is Flutter so good?</h4><p>Flutter is easy to port to different platforms because it has a clearly separated three-layer architecture and a very strong design from the start.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Y0FJd7a_Xp8WnbYuWwsvzg.png" /></figure><p>The Flutter framework consists of three main layers:</p><p><strong>Framework (Dart).<br></strong>This layer is written entirely in Dart and includes everything the developer works with directly: the widget system, animations, user input handling, and so on. The framework code is fully cross-platform and doesn’t need to change when you run it on different operating systems.</p><p><strong>Flutter Engine.<br></strong>This is a high-performance engine written in C/C++. It’s responsible for rendering the UI (through Skia or Impeller) and executing Dart code. This is the layer that actually draws the beautiful widgets your Flutter developer writes. The engine can be built for any target platform.</p><p>For example, when you’re creating your own system, you can build the Flutter Engine for it and use the full power of the framework without touching the upper layer. The main job of this layer is to run the code and render graphics.</p><p><strong>Embedder.<br></strong>This is the low-level layer that connects the Flutter Engine to a specific platform. It creates the rendering window, handles input, manages the app lifecycle and talks to system APIs.</p><p>When porting Flutter to a new platform, this is the part you need to modify, because it defines how and where the engine draws and how the app integrates with the operating system.</p><h4>Conclusion</h4><p>I want to wrap up this first part about Flutter’s advantages with this thought: the list of platforms I’ve mentioned will at least double or even triple in the next 10 years. Today, creating new platforms has become much easier, and multi-agent systems are helping a lot.</p><p>If you’re building an app, chances are that at some point you’ll need to port it to new systems that haven’t even appeared yet. In that sense, Flutter is an irreplaceable tool.</p><p>In the second part of this article, I’ll talk about how to start a project so that it’s easy to port it to different platforms later.</p><p>In the meantime, share in the comments what you like about Flutter (or what you don’t)!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ebfdd4bd73b5" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>