<?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[Version 1 - Medium]]></title>
        <description><![CDATA[A true global leader in business transformation. Our deep expertise in cloud, data and AI, application modernisation, and service delivery management has redefined businesses globally, helping shape the future for large public sector organisations and major global, private brands - Medium]]></description>
        <link>https://medium.com/version-1?source=rss----3faaba3c731e---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>Version 1 - Medium</title>
            <link>https://medium.com/version-1?source=rss----3faaba3c731e---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 05:55:48 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/version-1" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[How MCP Turns Claude into Your Personal Data Analyst]]></title>
            <link>https://medium.com/version-1/how-mcp-turns-claude-into-your-personal-data-analyst-ef9dd007d8bd?source=rss----3faaba3c731e---4</link>
            <guid isPermaLink="false">https://medium.com/p/ef9dd007d8bd</guid>
            <category><![CDATA[ai-data-analytics]]></category>
            <category><![CDATA[data-analysis-chatbot]]></category>
            <category><![CDATA[model-context-protocol]]></category>
            <category><![CDATA[ai-agents-data-analysis]]></category>
            <category><![CDATA[mcp-server]]></category>
            <dc:creator><![CDATA[Ashish Bansal]]></dc:creator>
            <pubDate>Fri, 01 May 2026 08:41:55 GMT</pubDate>
            <atom:updated>2026-05-01T08:41:54.161Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Model Context Protocol (MCP) is the universal interface between AI models, tools, and data." src="https://cdn-images-1.medium.com/max/1024/1*zPj_H-dhKYDnPOSaTqHZMw.png" /></figure><h4>The Problem Every Data-Rich Business Eventually Faces</h4><p>If you run a business, you probably have a database somewhere full of precious information. Sales records. Customer orders. Product performance. Regional breakdowns. The kind of data that could answer nearly any business question you might ask — <em>if only you could ask it directly</em>.</p><p>But in practice, asking that data a question, usually looks like this: you message someone on your team, they write a SQL query, they export it to a spreadsheet, they send it back. A simple question like “how did we do in the North region last week?” eats thirty minutes of someone’s day. Multiply that across your organisation and you’ve got a small industry of people asking questions of the same data, one request at a time.</p><p>For weeks I’d been thinking about this problem and wondering how to build a simple, yet effective, solution through AI. I was not willing to spend too much time and energy on developing extensive RAG Pipelines or any other complicated solution. Yes, you can use RAG but its like asking a Full scale Lorry to drop a simple letter! What I really wanted was to try a Agentic AI kind of Proof of Concept (PoC) that can be delivered to SMEs (Small Medium Enterprises) - A solution that would simply help a business owner chat with its sales database in plain English by just opening an app (both on desktop and mobile), type “what were our top five products last month?”, and get an answer within seconds — complete with the actual numbers, pulled live from the database instead of using CSV files.</p><p>This is a post about how I got there.</p><h4>Why I Chose the MCP Approach</h4><p>When I started researching, the options fell into four buckets.</p><p>The first was <strong>building a full custom application</strong> — a chatbot frontend, a backend service, database connectors, user authentication, the lot. Powerful but overkill for a team of one; I’d still be coding six months from now.</p><p>The second was <strong>SaaS platforms like Zapier</strong> that promise to connect anything to anything. The problem: my database sits on a VPS for security reasons. Punching holes in my firewall so a cloud service could reach my database felt like undoing the very thing that made the setup secure. I could have still found a way to secure my connection but I wanted slightly more challenging than simply use plug n play kind of solution.</p><p>The third was <strong>visual automation tools</strong> like n8n, which I would eventually use for scheduled reports — but not for the chatbot itself. n8n is wonderful for “at 8 AM every morning, do this thing”, but less ideal for conversational back-and-forth.</p><p>The fourth was <strong>MCP — Model Context Protocol</strong> — an open standard that Anthropic released to let AI assistants talk to external data sources in a structured, secure way. MCP turned out to be exactly what I needed, for a few reasons:</p><ul><li><strong>It’s purpose-built for this job.</strong> Unlike the generic tools, MCP was designed for the specific problem of “let an AI safely query my data.” It handles the plumbing — authentication, tool discovery, structured responses — so I didn’t have to.</li><li><strong>It’s future-proof.</strong> If I ever migrate from PostgreSQL to Snowflake or any other Database/Datawarehouse, I don’t have to rebuild my chatbot. I just swap the MCP server’s database connection. Claude Desktop, my user experience, everything else stays identical.</li><li><strong>It’s an open standard.</strong> MCP isn’t locked to Anthropic. Other AI assistants are adopting it too. I’m not committing to a single vendor.</li><li><strong>And critically: Claude Desktop already supports it out of the box.</strong> That meant I didn’t have to build a chat interface. The beautiful chat experience I was going to spend weeks coding? Already done. I just had to build the “server” side — the bit that knows how to query my database — and point Claude Desktop at it.</li></ul><p>Here’s how the final architecture looks. There are three layers:</p><ul><li><strong>My PC/Laptop</strong>: A user running Claude Desktop, which I already use daily which will be used as Chatbot tool to ask questions.</li><li><strong>My VPS</strong>: running PostgreSQL sales database and a small “MCP server” that acts as a safe gateway to that database. To simulate an actual business scenario I setup a PostgreSQL Database and populated it with synthetic fabricated data (again generated and downloaded through Claude). This DB would run on my own VPS (Virtual Private Server).</li><li><strong>The internet between them</strong>: secured with HTTPS and a token, so only my PC can talk to my MCP server</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*n-XnIRbRZYGSaH9ODiELZQ.png" /></figure><p>Now let me walk you through how I built it, step by step.</p><h4>Step 1: Lock Down the Database First</h4><p>Before anything else, I made sure the AI would only ever be able to <strong><em>read</em></strong> my data, <strong><em>never modify</em></strong> it. This is the most important step in the whole setup.</p><p>I created a dedicated database user called analytics_bot with read-only access to the sales table. Even if something went wrong, even if the AI misbehaved, the worst it could ever do was read data. It couldn&#39;t delete records, modify them, or access other tables.</p><blockquote>Since this was more of a PoC, I did not want to complicate it with multiple tables joined through SQL Query and having full scale Data Modelling structure. That’s something for future development.</blockquote><p>I connected to PostgreSQL (through SSH) and ran:</p><pre>CREATE USER analytics_bot WITH PASSWORD &#39;a-strong-password-here&#39;;<br><br>\c sales_db<br><br>GRANT CONNECT ON DATABASE sales_db TO analytics_bot;<br>GRANT USAGE ON SCHEMA public TO analytics_bot;<br>GRANT SELECT ON public.sales TO analytics_bot;</pre><p>Then I tested it by logging in as this new user and trying to write something — it correctly refused. Peace of mind secured!</p><h4>Step 2: Build the MCP Server</h4><p>Next came the “middle layer” — a small program that sits on my server, speaks the MCP protocol to the outside world, and turns AI requests into safe database queries.</p><p>I created a folder on my server and set up an isolated Python environment for it:</p><pre>sudo mkdir -p /opt/analytics-mcp<br>cd /opt/analytics-mcp<br>python3 -m venv venv</pre><p>Then I installed the tools I needed — the official MCP library, a PostgreSQL connector, and a couple of utilities:</p><pre>./venv/bin/pip install mcp &quot;psycopg[binary]&quot; python-dotenv pydantic</pre><p>I saved my database password and a secret auth token in a protected file called .env:</p><pre>DATABASE_URL=postgresql://analytics_bot:password@localhost:5432/sales_db<br>MCP_AUTH_TOKEN=a-long-random-string-used-as-a-password<br>QUERY_TIMEOUT_SECONDS=10<br>MAX_RESULT_ROWS=10000</pre><p>Then I wrote the actual MCP server — a Python file that defines specific “Tools” the AI can call. Rather than giving the AI free rein over my database, I created narrow, purpose-built functions: <em>summarise sales between two dates</em>, <em>list the top products</em>, <em>break down sales by region</em>. The AI can only do what I’ve explicitly allowed. This will prevent it from hallucinating.</p><p>Here’s a simplified (trimmed down) version of what that looks like (file saved as server.py). <em>NB: I have not included all the tools to keep the blog short</em>:</p><p>You can download the necessary files (along with CSV data file which was used to upload to PostgreSQL DB) from my Github Repo <a href="https://github.com/ashgit3/Analytics-MCP">here</a>.</p><pre>from mcp.server.fastmcp import FastMCP<br>import psycopg, os<br>from dotenv import load_dotenv<br><br>load_dotenv()<br><br>mcp = FastMCP(&quot;sales-analytics&quot;, host=&quot;127.0.0.1&quot;, port=8765)<br><br>@mcp.tool()<br>def get_sales_summary(start_date: str, end_date: str) -&gt; str:<br>    &quot;&quot;&quot;Get total revenue, order count, and average order value.&quot;&quot;&quot;<br>    with psycopg.connect(os.getenv(&quot;DATABASE_URL&quot;)) as conn:<br>        with conn.cursor() as cur:<br>            cur.execute(&quot;&quot;&quot;<br>                SELECT COUNT(*), SUM(amount), AVG(amount)<br>                FROM sales<br>                WHERE sale_date BETWEEN %s AND %s<br>            &quot;&quot;&quot;, (start_date, end_date))<br>            return str(cur.fetchone())<br><br>if __name__ == &quot;__main__&quot;:<br>    mcp.run(transport=&quot;streamable-http&quot;)</pre><p>That’s the whole pattern: I define a function, decorate it with @mcp.tool(), and Claude can now call it. Each tool I added gave the AI another capability while keeping the database safely behind a small set of well-defined doors.</p><h4>Step 3: Make the Server Run Forever</h4><p>A server that crashes when you log out isn’t of much use. I configured my VPS to keep the MCP server running permanently — restart it automatically if it crashes, start it automatically when the VPS reboots.</p><p>I created a small system configuration file as /etc/systemd/system/analytics-mcp.service:</p><pre>[Unit]<br>Description=Sales Analytics MCP Server<br>After=postgresql.service<br><br>[Service]<br>Type=simple<br>User=www-data<br>WorkingDirectory=/opt/analytics-mcp<br>EnvironmentFile=/opt/analytics-mcp/.env<br>ExecStart=/opt/analytics-mcp/venv/bin/python3 server.py<br>Restart=always<br><br>[Install]<br>WantedBy=multi-user.target</pre><p>Then started it up:</p><pre>sudo systemctl enable analytics-mcp<br>sudo systemctl start analytics-mcp</pre><p>Now the MCP server was running 24/7, listening quietly on port 8765 on the server itself. But it was only reachable from inside the server — from the outside world, it was invisible. Which was exactly right, because the next step would add secure public access.</p><h4>Step 4: Expose It Safely to the Internet</h4><p>I needed my PC to reach the MCP server from anywhere — but I didn’t want anyone else to. The solution was a subdomain (mcp.mydomain.uk) pointing to my server, protected by three layers:</p><ul><li><strong>HTTPS encryption</strong> (so traffic in transit is scrambled)</li><li><strong>A secret token</strong> in the request headers (so only requests that know the password get through)</li><li><strong>The server firewall</strong> (so port 8765 itself stays invisible to the internet — access only happens through the proper web address)</li></ul><p>I already had Plesk managing my VPS, so I created the subdomain, clicked two buttons to install a free HTTPS Let’s Encrypt certificate, and added a handful of lines of reverse-proxy config for nginx:</p><pre>location /mcp {<br>    if ($http_authorization != &quot;Bearer my-secret-token&quot;) {<br>        return 401;<br>    }<br>    <br>    proxy_pass http://127.0.0.1:8765;<br>    proxy_http_version 1.1;<br>    proxy_set_header Host 127.0.0.1:8765;<br>    proxy_buffering off;<br>    proxy_read_timeout 120s;<br>}</pre><p>The first block says: “if the request doesn’t include my secret token, reject it.” The rest says: “otherwise, forward it to my MCP server.”</p><p>After a quick test from my PC confirmed I could reach the endpoint, I was ready for the final step.</p><h4>Step 5: Point Claude Desktop at It</h4><p>Claude Desktop supports MCP servers, but at the time I set this up, its config file only natively accepted local servers — not remote ones like mine. The workaround was a small tool called mcp-remote that runs on my PC and acts as a bridge: Claude Desktop talks to it locally, and it forwards everything to my server over HTTPS.</p><p>After installing Node.js on my PC, I edited Claude Desktop’s configuration file (claude_desktop_config.json) to tell it about my new server:</p><pre>{<br>  &quot;mcpServers&quot;: {<br>    &quot;sales-analytics&quot;: {<br>      &quot;command&quot;: &quot;C:\\Program Files\\nodejs\\npx.cmd&quot;,<br>      &quot;args&quot;: [<br>        &quot;-y&quot;,<br>        &quot;mcp-remote&quot;,<br>        &quot;https://mcp.mydomain.uk/mcp&quot;,<br>        &quot;--header&quot;,<br>        &quot;Authorization:${AUTH_HEADER}&quot;<br>      ],<br>      &quot;env&quot;: {<br>        &quot;AUTH_HEADER&quot;: &quot;Bearer my-secret-token&quot;<br>      }<br>    }<br>  }<br>}</pre><p>Fully quit Claude Desktop, reopened it, and there it was — my sales analytics tools showing up in Claude’s tool list, ready to use.</p><h3>The Payoff</h3><p>I opened a fresh conversation and typed:</p><blockquote>“What were our top five products by revenue last month?”</blockquote><p>Three seconds later, Claude had called my MCP server, which queried my PostgreSQL database, which returned the numbers. Claude presented them in a clean narrative with specific figures: “Your top product was X at £Y, followed by Z at…”</p><p>I tried a few more:</p><blockquote>“Compare sales in the North region versus the South for Q1.”<em> </em>“Were there any unusual spikes in daily revenue last week?”<em> </em>“Which customers haven’t ordered in the last 90 days?”</blockquote><p>Every one of them worked. Each question that would have taken someone on my team half an hour was now answered instantly by me, in plain English, pulling live from my own data on my own server.</p><p>Screenshot of a sample output from Claude Desktop:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/544/1*oxreBzyZfMTxtGV6DPc4Ew.png" /></figure><h3>What I learned along the way</h3><p>A few reflections in case you’re thinking about doing the same:</p><p><strong>Start narrow, not wide.</strong> My instinct was to give the AI total access to my database so it could answer anything. That’s a security mistake <em>and</em> a user experience mistake — broad access means broad opportunity for wrong answers. Defining a small set of focused tools gave me better answers <em>and</em> safer ones.</p><p><strong>Use a read-only database user.</strong> I cannot stress this enough. The AI is clever. Don’t give it the keys to the city when all you need is a reading pass.</p><p><strong>The MCP ecosystem is young but growing fast.</strong> I hit a few rough edges — Claude Desktop didn’t have native UI for remote servers, error messages were occasionally cryptic, some auth patterns were still being worked out. But none of it was show-stopping, and all of it got resolved within a session of Googling. The protocol itself is solid, and more tools arrive every month.</p><p><strong>This scales.</strong> The exact same MCP server that powers my Claude chat can also power my automated daily reports, my Slack bot, my Teams integration — anything that speaks MCP. I’ve built the plumbing once; adding new surfaces on top is trivial now.</p><h4>Limitations of MCP (at least in my context)</h4><p>I understand that in order to prevent AI from hallucinating, and giving AI free hand to execute queries on a DB, there are guardrails in place in form of tools. So any Analytics query is only limited to what Tools have been predefined in server.py file. Any user query that is out of the scope from this tool and Claude Desktop would gently refuse to answer.</p><p>However, it’s a deployment choice more than an intelligence ceiling. That gap is intentional on the deployment side. Letting an AI freely execute arbitrary SQL against a production database raises real concerns — accidental expensive queries, schema assumptions that turn out wrong, write operations, data exfiltration risks, permission scoping. So developers typically expose a curated set of parameterised functions instead (aka Tools). It’s the same logic as giving a contractor a specific set of keys rather than the master key.</p><p>Can AI invent new capabilities on the fly when the predefined ones don’t fit — is more interesting. In agentic setups (like Claude Code, or environments with code execution), it genuinely can write and run new code to solve problems the original tools didn’t anticipate. As said, Claude Code can rescue here and that’s something which I am going to play with in near future!</p><h3>What’s Next</h3><p>Now that the chatbot works, I’m planning to use the same MCP server to power a few other things:</p><ul><li>An automated daily summary that lands in Microsoft Teams every morning, using n8n.</li><li>A weekly executive report delivered via email</li><li>Potentially a small internal chatbot a team can use without needing Claude Desktop</li></ul><p>All of it will reuse the same MCP server I’ve already built. That’s the beauty of this architecture — one piece of plumbing, many ways to use it.</p><p>If you have data on your own server, I genuinely can’t recommend this approach enough. You don’t need to be a developer. You need a weekend, a little patience with the command line, and the willingness to ask Claude itself for help when you get stuck (which, meta-ly, is how much of this project actually came together).</p><p>Your database has been sitting there holding answers for you. Why not let it talk back?</p><p><em>This exercise was done to test the concept of MCP and how it can be implemented in a real life scenario however only specific to SME. When it comes a large enterprise who uses Data warehouses, the way you connect may change significantly however the basic premise would still remain the same. For larger organisations with huge datasets, one might even need to implement RAG strategies.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/700/1*_-Zlay1cJizNs9mWKzF50A.png" /></figure><p><strong>About the Author:<br></strong>Ashish is a Senior Data Consultant at <a href="https://www.version1.com/">Version 1</a>, providing data solutions that help businesses make better data-driven decisions. With key focus on creating simple and efficient solutions, Ashish ensures customers get real value for their data.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ef9dd007d8bd" width="1" height="1" alt=""><hr><p><a href="https://medium.com/version-1/how-mcp-turns-claude-into-your-personal-data-analyst-ef9dd007d8bd">How MCP Turns Claude into Your Personal Data Analyst</a> was originally published in <a href="https://medium.com/version-1">Version 1</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Your AI Agents Need an Operating System: Harnesses, Orchestration, and the Permission Model]]></title>
            <link>https://medium.com/version-1/your-ai-agents-need-an-operating-system-harnesses-orchestration-and-the-permission-model-7c1c140590b1?source=rss----3faaba3c731e---4</link>
            <guid isPermaLink="false">https://medium.com/p/7c1c140590b1</guid>
            <category><![CDATA[large-language-models]]></category>
            <category><![CDATA[ai-agent-harness]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <category><![CDATA[ai-engineering]]></category>
            <dc:creator><![CDATA[Muhammad Azam Mehr Ghulam]]></dc:creator>
            <pubDate>Mon, 27 Apr 2026 08:04:36 GMT</pubDate>
            <atom:updated>2026-04-27T08:04:35.151Z</atom:updated>
            <content:encoded><![CDATA[<h4>Building agents is easy. Running them safely in production requires harness engineering, smart orchestration, and a layered permission model.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kA3GRFQ4bhmmQ5movu9eJg.jpeg" /></figure><p><em>This is Part 1 of a two-part series, building on my previous articles on single-agent design and MCP.</em></p><p>To see why all three matter, picture a corporate assistant where an HR agent handles employee records, a finance agent queries budgets, and an IT agent manages tickets. The moment these agents start working together, four problems show up almost immediately, and none of them have clean answers in today’s frameworks:</p><ol><li><strong>Identity</strong>: What identity is each agent using to access its data source?</li><li><strong>Access <em>(agent boundary)</em></strong>: If the finance agent needs employee context to process an expense, what stops it from reading salary records it has no business seeing?</li><li><strong>Enforcement <em>(user boundary)</em></strong>: If a user can only view their own department’s records, does the agent respect that limit, or does it query everything via a shared service account?</li><li><strong>Continuity</strong>: As context is compacted and handed off between agents, how do you ensure permission decisions and user identity are never lost along the way?</li></ol><p>Modern agent frameworks can verify who is making a request. Whether that request should be allowed (which tool, which data, which action) is left entirely to you.</p><p>Getting an large language model (LLM) to execute a tool is a solved problem. The engineering challenge lies in the <strong>harness</strong> that manages its lifecycle, the <strong>orchestration</strong> that coordinates multiple agents, and the <strong>permission model </strong>that keeps each one within its boundaries. This article covers all three.</p><blockquote><a href="https://www.version1.com/ai-strategy-and-implementation/">AI strategy and implementation — Version 1</a></blockquote><h3>What Is an Agent Harness?</h3><p>If the LLM is the CPU and the context window is RAM, the <strong>harness is the operating system</strong>. It manages everything the model cannot manage itself: session state, memory, tool execution, recovery from crashes, and the audit trail that proves what happened and why.</p><p>In practice, a production harness brings together eight distinct responsibilities. Each one addresses a failure mode that has bitten real teams in production:</p><figure><img alt="Harness components" src="https://cdn-images-1.medium.com/max/777/1*PGiEBijTQvNDH13t4BR3UQ.jpeg" /></figure><blockquote>Build the harness before you build the second agent.</blockquote><p>Most teams discover they need a harness only after their first production incident: an agent that loops forever, leaks context across users, or quietly fails halfway through a transaction with no record of what it touched.</p><h3>Orchestration Patterns: How Agents Work Together</h3><p>A robust harness keeps a single agent alive. The harder problem starts when several agents need to work together, and that is where orchestration comes in.</p><p>In a hospital A&amp;E department, a triage nurse evaluates each patient and routes them to the right specialist. The nurse does not perform surgery, but without the nurse, the surgeon would be overwhelmed with minor complaints.</p><p>That is orchestration. To do it right, you must distinguish between <strong>workflows </strong>(static sequences defined in code) and <strong>agents</strong> (dynamic behaviour decided by the LLM). Successful orchestration uses deterministic workflows to control non-deterministic agents.</p><p>Four orchestration patterns dominate production systems today. They differ in where the routing decision lives and how much autonomy the LLM has over the flow.</p><h4>Pattern 1: The Supervisor (Orchestrator as Classifier)</h4><p>A central orchestrator agent receives all user requests, classifies the intent, and routes to the appropriate specialist.</p><p><strong><em>Best for (agent-driven):</em></strong><em> Enterprise workflows with distinct data domains like HR or Finance.</em></p><h4>Pattern 2: Routing Workflow (Conditional Branching)</h4><p>User input is processed by a simple function or keyword matcher. If certain keywords appear, processing branches to a specific specialist.</p><p><strong><em>Best for (deterministic workflow):</em></strong><em> Simple intent-based branching where the routing logic is deterministic.</em></p><h4><strong>Pattern 3: Hierarchical Delegation (Agent-as-Tool)</strong></h4><p>Agents can invoke other agents as if they were tools. A “research agent” might call a “web search agent” as a sub-task.</p><p><strong><em>Best for (agent-driven): </em></strong><em>Tasks that decompose naturally into sub-tasks with clear outputs.</em></p><h4>Pattern 4: Evaluator-Generator (Verification Loop, hybrid: deterministic loop, agent-driven content)</h4><p>One agent generates output while a second agent evaluates it. If it fails, the evaluator sends feedback for a retry.</p><p><strong><em>Best for (hybrid): </em></strong><em>Quality-critical outputs where “close enough” is not acceptable.</em></p><h3>A 4-Layer Permission Model</h3><p>Routing requests to the right specialist is only half the multi-agent challenge. The other half is making sure each specialist stays inside its mandate once the request arrives.</p><p>A solicitor acts on behalf of a client, but cannot exceed the client’s authority. They cannot sign contracts the client did not approve, transfer money the client did not authorise, or share information the client did not consent to release. An agent is no different. The Open Worldwide Application Security Project (OWASP) Top 10 for Agentic Applications (released December 2025) formally catalogues risks such as <strong>ASI03: Identity &amp; Privilege Abuse</strong>. When an agent acts on behalf of a user, it inherits that user’s risks. To solve this, I recommend a layered approach.</p><h4>Layer 1: Traditional RBAC</h4><p>Role-Based Access Control (RBAC) assigns roles like “Manager” or “Employee.” While necessary, it is insufficient on its own. A coding agent with a “Manager” role might still drop a production database because it was the most efficient way to “clean up the system.”</p><h4>Layer 2: Agent-Specific Scope</h4><p>Each specialist agent should have a defined boundary. This restricts the agent itself, regardless of who is asking. An IT support agent should never have the ability to query the salary table in the HR database. This is enforced through tool allowlists and a “default-deny” policy.</p><h4>Layer 3: User-Context Propagation</h4><p>This is the hardest layer to get right, and the place where most multi-agent systems quietly fail. The user’s identity and access context must flow through the entire delegation chain, and almost no framework gives you this for free.</p><p>Consider a typical scenario. A user with regional access asks the orchestrator a question. The orchestrator delegates to a specialist agent. The specialist queries a database using a service account that can see every record in the system. Somewhere between the user logging in and the SQL hitting the database, the user’s identity has quietly evaporated. The agent now returns data the user was never authorised to see, and no audit log will catch it, because from the database’s perspective the service account was perfectly entitled to read it.</p><p>Solving this requires three commitments. First, the user’s identity and access context must travel with every request as it crosses agent boundaries, not sit implicitly inside conversation state. Second, the harness must persist that identity outside the LLM context window, so context compaction cannot strip it during summarisation. Third, the tools themselves must apply the user’s restrictions at the data layer, not trust the agent to filter results after the fact.</p><p>An agent that forgets who it is acting for is an agent that has just become a privilege escalation vector, and one that can no longer answer the Identity or Enforcement questions you asked at the start.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_470_cUXy295tp72pKmDfg.png" /></figure><h4><strong>Layer 4: Runtime Guardrails</strong></h4><p>This layer catches unexpected behaviour or malicious attempts at goal hijacking (ASI01 in the OWASP Agentic Top 10), where an agent is manipulated by instructions embedded in the data it reads. Layer 4 includes:</p><ul><li><strong>Circuit breakers</strong>: Halting the agent if it enters an infinite loop.</li><li><strong>Execution budgets</strong>: Capping tool calls and token usage per session.</li><li><strong>Human-in-the-loop gates:</strong> Requiring manual approval for high-impact actions like processing a payment.</li></ul><h3>The 2026 Landscape: Frameworks vs Governance</h3><p>Building the harness, orchestration, and permission layers yourself is the hard path. The industry is rapidly building tooling that addresses all three.</p><p>The choice of framework often dictates how you implement these patterns. <strong>LangGraph</strong> remains the leading open-source choice for production due to its explicit state management. <strong>CrewAI </strong>offers an intuitive role-based model that gets teams to a working prototype quickly, though many migrate to LangGraph when state management complexity increases, while Google ADK provides native <strong>Agent-to-Agent</strong> (A2A) protocol support.</p><p>However, we are now seeing a shift toward dedicated governance layers that sit <strong>above </strong>the framework. In early April 2026, Microsoft released the <strong>Agent Governance Toolkit</strong>: an open-source, framework-agnostic system that provides deterministic policy enforcement and cryptographic agent identity. Similarly, <strong>Amazon Bedrock</strong> AgentCore’s Policy feature allows developers to define tool access using the Cedar policy language.</p><p>These tools move us away from “probabilistic security” (hoping the agent follows instructions) toward “deterministic security” (the gateway denying the tool call before it executes). If you are building a custom stack, none of this comes for free. The four-layer model above is where to start.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PvzEtBqOrwRBDpWUfhpFnQ.png" /></figure><h3>Looking Ahead: Building OpsAssist</h3><p>In Part 2, we move from theory to working code. We will build <strong>OpsAssist,</strong> a multi-agent corporate assistant with HR, Finance, and IT specialists, and you will learn how to:</p><ul><li>Wrap a LangGraph agent in a custom Python harness that manages session state and audit logging</li><li>Implement a Supervisor that routes requests to the right specialist without leaking context between domains</li><li>Build a ‘PermissionGuard’ class that enforces all four layers, including user identity and access context that survives compaction and agent handoff</li><li>Add a deterministic policy enforcement layer using the Microsoft Agent Governance Toolkit, and see how it compares to your custom PermissionGuard</li><li>Deploy the whole stack with Docker, with a public GitHub repo to fork</li></ul><p>Building an agentic system is no longer just about the prompts. It is about building the operating system that ensures those prompts stay within the lines.</p><h4>About the author</h4><p>Muhammad Azam Mehr Ghulam is an AI Technical Lead here at <a href="https://www.version1.com/">Version 1</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7c1c140590b1" width="1" height="1" alt=""><hr><p><a href="https://medium.com/version-1/your-ai-agents-need-an-operating-system-harnesses-orchestration-and-the-permission-model-7c1c140590b1">Your AI Agents Need an Operating System: Harnesses, Orchestration, and the Permission Model</a> was originally published in <a href="https://medium.com/version-1">Version 1</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Forget Manual Labelling: Using Google Gemini to Annotate Training Data for Computer Vision Models]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/version-1/forget-manual-labelling-using-google-gemini-to-annotate-training-data-for-computer-vision-models-527491924049?source=rss----3faaba3c731e---4"><img src="https://cdn-images-1.medium.com/max/1536/1*1SRTRTsovTJlwEFJRtTnjw.png" width="1536"></a></p><p class="medium-feed-snippet">If you have ever trained a computer vision model from scratch, you will know that the model architecture is rarely the hard part. Getting&#x2026;</p><p class="medium-feed-link"><a href="https://medium.com/version-1/forget-manual-labelling-using-google-gemini-to-annotate-training-data-for-computer-vision-models-527491924049?source=rss----3faaba3c731e---4">Continue reading on Version 1 »</a></p></div>]]></description>
            <link>https://medium.com/version-1/forget-manual-labelling-using-google-gemini-to-annotate-training-data-for-computer-vision-models-527491924049?source=rss----3faaba3c731e---4</link>
            <guid isPermaLink="false">https://medium.com/p/527491924049</guid>
            <category><![CDATA[computer-vision]]></category>
            <category><![CDATA[generative-ai]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[innovation]]></category>
            <dc:creator><![CDATA[Rohit Vincent]]></dc:creator>
            <pubDate>Fri, 10 Apr 2026 08:14:40 GMT</pubDate>
            <atom:updated>2026-04-10T08:14:39.400Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[AI in data engineering: Why fundamentals matter more than ever]]></title>
            <link>https://medium.com/version-1/ai-in-data-engineering-why-fundamentals-matter-more-than-ever-2a9b31022f98?source=rss----3faaba3c731e---4</link>
            <guid isPermaLink="false">https://medium.com/p/2a9b31022f98</guid>
            <category><![CDATA[data]]></category>
            <category><![CDATA[data-engineering]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[data-visualisation]]></category>
            <dc:creator><![CDATA[Marco Frondella]]></dc:creator>
            <pubDate>Fri, 10 Apr 2026 08:04:56 GMT</pubDate>
            <atom:updated>2026-04-10T08:25:54.992Z</atom:updated>
            <content:encoded><![CDATA[<h4>Fundamentals make AI work harder</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Q5L0JBVjkEEkhksNXdAFUQ.png" /></figure><p>AI has the potential to remove friction from data engineering in ways most of us did not anticipate. Generating synthetic datasets used to require careful scripting. Now it can be as simple as a prompt. Debugging SQL used to mean reading stack traces line by line, scrolling google. Now a screenshot might be able to steer you in the right direction.</p><p>That friction used to serve a purpose. It forced engineers to understand the systems they were building and the context they were building them within, the business problem they were trying to solve. Without it, the gap between producing code and understanding code gets wider every day.</p><p><em>If AI can generate the basic code, does it matter whether someone can write it themselves?</em></p><h3>When tools get better, bad work gets easier</h3><p>We have all seen it. Code that technically runs but falls apart the moment someone else has to maintain it. Brittle, insecure, and built to pass a demo rather than exist in production environments.</p><p>AI makes it easy to produce an output. But it does not make it easy to produce understanding. When someone lacks strong fundamentals, AI becomes a factory for code or any output that looks right, but behaves wrongly.</p><p>The cost shows up downstream. Data engineering exists to solve business problems: reliable reporting, trustworthy data products, insights that people actually act on. When the underlying pipelines are fragile, those outcomes suffer regardless of how quickly it took to deliver.</p><p><strong>AI removes friction</strong></p><p>AI removes the friction<em> </em>that used to teach people how systems actually work. When that friction disappears, so does the opportunity to build real, hands-on experience.</p><p>The result is a growing gap between engineers who understand what the AI is doing and those who simply accept whatever it gives them.</p><p><strong>The future engineer needs both</strong></p><p>We are heading into a world where having only one of the following will hold you back.</p><p>Data Engineering Fundamentals without AI: you understand distributed systems, data modelling, performance tuning, and orchestration etc., but you cannot leverage AI to move faster. Someone with half your experience will outpace you, because AI can enable efficiency gains to anyone who knows how to ask the right questions, in the right why and more importantly validate the answers.</p><p>AI skills without fundamentals: you rely entirely on AI without understanding the principles underneath. You will use vulnerable code, inefficient queries, and pipelines held together by hope. You become dangerously productive, but you create more problems than you solve.</p><p>The engineers and organisations who will thrive are the ones with strong data engineering fundamentals who treat AI as an enabler, not a replacement for thinking. They are the ones who can connect a well-built artefacts to a real business outcome.</p><h3><strong>Fundamentals make AI work harder</strong></h3><p>People assume that AI levels the playing field. In practice, it widens the gap between engineers who understand the domain and those who do not.</p><p>People with strong fundamentals know when the AI is wrong. They write better prompts. They steer AI toward sound designs rather than accepting the first output. They understand trade-offs that AI cannot articulate. And they can fix what the AI breaks.</p><p>Learning to use AI tools takes months. Building genuine engineering fundamentals takes years of experience, mistakes, debugging, and learning how systems really behave under pressure.</p><p>Fundamentals will remain the harder skill to acquire, and that is exactly what makes them valuable.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*u4lO_SF5lSRSI7pEqmHKkA.png" /></figure><h3><strong>AI’s biggest value today: efficiency, not genius</strong></h3><p>There is plenty of talk about AI solving the hard problems. But right now, the biggest return comes from time savings, automating routine tasks, generating boilerplate, supporting documentation and testing, and translating requirements into starter code.</p><blockquote><a href="https://www.version1.com/ai-strategy-and-implementation/">AI strategy and implementation — Version 1</a></blockquote><p>AI solves straightforward problems at scale far better than it solves complex problems well. We are not at the point where AI can architect a secure, high-performance data platform on its own. Pretending otherwise is how organisations accumulate technical debt.</p><p><strong>Where this leaves data engineering</strong></p><p>The value of data engineering shifts toward architecture and system design, optimising for scale, cost, and reliability, making high-judgement calls, validating AI-generated work, and guiding AI rather than being replaced by it.</p><p>The engineers who will matter most are those who use AI to accelerate delivery while keeping the focus where it belongs: on solving business problems through well-engineered data. Speed without purpose is just noise. AI paired with strong fundamentals and a clear understanding of what the business “actually” needs is where the real value sits.</p><p>AI will not make good data engineering obsolete. It will make poor data engineering impossible to hide. AI will not make skilled engineers obsolete. It will make unskilled engineers extremely visible. And it will increase the demand for senior engineers and skilled practitioners who can pair deep expertise/domain knowledge with AI-driven speed.</p><p><strong>Key takeaways:</strong></p><ul><li>AI removes the friction that used to build understanding.</li><li>Data engineering exists to solve business problems, not just generate code faster.</li><li>The future belongs to practitioners with both deep fundamentals and AI fluency.</li><li>AI’s biggest return today is efficiency, not replacing complex thinking.</li><li>Poor data engineering is about to become impossible to hide.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/700/0*8-A7L2vmt2UJ_moh.png" /></figure><p><strong>About the Author:<br></strong><a href="https://www.linkedin.com/in/marcofrondella">Marco</a> is a Lead Data Consultant at <a href="https://www.version1.com/">Version 1</a>, providing data solutions and visualisations expertise to organisations. With a Power BI focus, Marco helps to ensure customers get the best value from their data.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2a9b31022f98" width="1" height="1" alt=""><hr><p><a href="https://medium.com/version-1/ai-in-data-engineering-why-fundamentals-matter-more-than-ever-2a9b31022f98">AI in data engineering: Why fundamentals matter more than ever</a> was originally published in <a href="https://medium.com/version-1">Version 1</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Transformation theatre]]></title>
            <link>https://medium.com/version-1/transformation-theatre-b8430175dde1?source=rss----3faaba3c731e---4</link>
            <guid isPermaLink="false">https://medium.com/p/b8430175dde1</guid>
            <category><![CDATA[digital-transformation]]></category>
            <category><![CDATA[accountability]]></category>
            <category><![CDATA[change-leadership]]></category>
            <category><![CDATA[transformation-strategy]]></category>
            <category><![CDATA[organisational-change]]></category>
            <dc:creator><![CDATA[Natalia Lebedenko]]></dc:creator>
            <pubDate>Mon, 02 Mar 2026 09:19:48 GMT</pubDate>
            <atom:updated>2026-03-02T09:19:47.431Z</atom:updated>
            <content:encoded><![CDATA[<p>It was a great meeting! Everyone left room in a good mood, congratulating each other for further refining the Digital strategy — visuals were added, key formulations refined, and colours of the document aligned to the corporate standard. As a note, this scenario isn’t about any specific organisation, rather a composite drawn from patterns I see repeatedly across highly regulated industries.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ijQr702x25BA67XSVk9nMw.png" /><figcaption>Image by AI</figcaption></figure><p>It was the third year of Digital Transformation Programme. The team agreed to meet again in two weeks to “better align” benefits metrics to deliverables. It was a very successful Transformation Programme… on paper.</p><p>Meanwhile, the organisation kept working as usual, mentioning “Digital Transformation” with sarcasm at the coffee machine.</p><p>I feel strongly about this because it reflects a recurring reality I’ve seen across highly regulated industries, such as banking, government, and oil &amp; gas: ambitious (or not so) strategies, extensive documentation, countless To-Be processes — yet transformation remains a document, not a lived change.</p><p>When I see these warning signs, I raise the red flag:</p><ul><li><strong>Why endless refinement?</strong> Why is your strategy in its 7th round before the first real step?</li><li><strong>Why paperwork over progress?</strong> What are you actually achieving?</li><li><strong>Where’s the impact?</strong> How much budget has been spent and what really changed?</li></ul><blockquote><a href="https://www.version1.com/enterprise-applications/">Enterprise Applications — Version 1</a></blockquote><p>Large programmes are complex and scary. They often succeed on paper but feel very different on the ground. What can we do about that?</p><ul><li>Take time to <strong>ask</strong> <strong>questions</strong> about the programme you lead, support, or observe. Maybe this is the day when you help the organisation to move from paper paralysis into the real world of experiment, learning and doing?</li><li>Bring <strong>accountability</strong> into the leadership team: what tangible outcomes have we delivered? Not documents, not reports, but the actual outcomes.</li><li>Publish <strong>transparent dashboards</strong> to track progress on benefits achieved. I find transparency to be highly undesirable in “transformation theatres” with lots of activity on paper.</li><li>Reset <strong>governance</strong>, usually something is broken high up when there are no meaningful outcomes.</li><li>And critically, create an environment where teams feel safe to experiment and take action.</li></ul><p>This is where we spend so much of our time with clients, helping them turn intent into momentum, and momentum into measurable and traceable business outcomes, so transformation becomes something lived, not laminated.</p><p><strong>What’s the one question you ask to move transformation beyond the slide deck?</strong></p><p><strong>What can be the smallest real-world change the team can deliver in the next 30 days that proves this transformation is more than just a document?</strong></p><h4><strong>About the Author</strong></h4><p><em>Natalia Lebedenko is the Principal Transformation consultant at </em><a href="https://www.version1.com/"><em>Version 1</em></a><em>, part of our Enterprise Applications Practice. Follow our Medium blog for more blogs on Change and Transformation from Natalia</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b8430175dde1" width="1" height="1" alt=""><hr><p><a href="https://medium.com/version-1/transformation-theatre-b8430175dde1">Transformation theatre</a> was originally published in <a href="https://medium.com/version-1">Version 1</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[When Money Moves: The Reliability Patterns That Power Modern Fintech]]></title>
            <link>https://medium.com/version-1/when-money-moves-the-reliability-patterns-that-power-modern-fintech-5d4eee355b02?source=rss----3faaba3c731e---4</link>
            <guid isPermaLink="false">https://medium.com/p/5d4eee355b02</guid>
            <category><![CDATA[reliability-engineering]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[financial-apis]]></category>
            <category><![CDATA[distributed-systems]]></category>
            <category><![CDATA[fintech]]></category>
            <dc:creator><![CDATA[Krizel Dias]]></dc:creator>
            <pubDate>Fri, 13 Feb 2026 13:46:46 GMT</pubDate>
            <atom:updated>2026-02-13T13:46:44.997Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Design patterns that keep financial systems safe, consistent, and correct.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*70TxitzW2_8jZy9BxuAT4w.jpeg" /></figure><p><em>Financial systems fail.</em><br><em>Networks drop.<br>Services timeout.<br>Gateways overload.</em></p><p>But users expect exactly one thing:<strong><br>👉 My money must be correct.</strong></p><p>Despite chaos behind the scenes, fintech systems stay accurate, consistent, and safe because they lean on a few critical reliability patterns.</p><blockquote><strong>Who’s This For?</strong></blockquote><blockquote>This article is for backend developers working in fintech. No finance experience needed — just a basic understanding of APIs and distributed systems.</blockquote><blockquote><a href="https://www.version1.com/industries/intelligently-transforming-financial-services-and-insurance/">Intelligently transforming financial services and insurance — Version 1</a></blockquote><p>In this article, we’ll break down three patterns every payments, banking, and trading engineer must master:</p><ul><li><strong>CAP Theorem</strong> — what you must sacrifice in distributed money systems</li><li><strong>Idempotency</strong> — the real reason “no duplicate charges” works</li><li><strong>Smart Retries</strong> — how to retry safely without breaking financial flows</li></ul><p>Whether you’re building payment APIs, ledger systems, or real‑time market dashboards, these patterns keep money moving the right way.</p><h3>1. CAP Theorem in Fintech: You Can’t Have Everything</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dDrHUu7gd3cYAz_mn4_aww.png" /></figure><p>CAP theorem says a distributed system can only guarantee <strong>two</strong> of the following at a time:</p><ul><li><strong>Consistency</strong> — reads always reflect the latest write</li><li><strong>Availability</strong> — the system always responds</li><li><strong>Partition Tolerance</strong> — the system continues despite network failures</li></ul><p>In fintech, <strong>Partition Tolerance is non‑negotiable</strong>.<br> Networks <em>will</em> fail.</p><p>So the real trade-off becomes:</p><h4>❗ Money‑moving systems choose Consistency over Availability (CP)</h4><p>Examples:</p><ul><li>Card authorization databases</li><li>Ledger systems</li><li>Fraud engines</li><li>Core banking platforms</li></ul><p>If a ledger becomes inconsistent even for a second, you risk:</p><ul><li>duplicated balances</li><li>incorrect reporting</li><li>double spending</li></ul><p>👉 <strong>Consistency is king when money is involved.</strong></p><h4>❗ Trading systems often choose Availability over Consistency (AP)</h4><p>Examples:</p><ul><li>Market data price tick streams</li><li>Real‑time dashboards</li><li>High‑frequency trading UI</li></ul><p>Here, slightly stale data (1–10ms old) is better than <em>no</em> data.</p><p>👉 <strong>If users can’t see data, they can’t trade.</strong></p><h4>Fintech takeaway</h4><p>Know which side of CAP you must prioritize:</p><ul><li><strong>CP</strong> → payments, ledgers, settlement</li><li><strong>AP</strong> → market data, dashboards</li></ul><p>CAP isn’t theory — it shapes real fintech architecture.</p><h3>2. Idempotency: The Secret Behind “No Double Charges”</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*L14GdR0QZhV8QCp9RuqIzQ.jpeg" /></figure><p>Imagine a user requests a £50 payment, but the network glitches.<br> The client retries.<br> Then retries again.</p><p>Without idempotency, the merchant could charge:</p><p>❌ once<br> ❌ twice<br> ❌ five times<br> ❌ or once per retry</p><p>Idempotency guarantees:</p><p>👉 <strong>“This operation has the same effect whether it’s done once or 100 times.”</strong></p><p>This is critical in:</p><ul><li>Payment gateways (Stripe, Adyen, Visa)</li><li>Bank transfers (SEPA, FPS, UPI)</li><li>Webhooks</li><li>Microservices</li><li>Trading order submission</li></ul><h4>How Idempotency Keys Work</h4><p>Client sends:</p><pre>Idempotency-Key: 1a2b3c4d</pre><p>Server stores:</p><ul><li>the key</li><li>the request payload</li><li>the result</li></ul><p>Any duplicate request with the same key returns the <strong>original result</strong>, not a new charge.</p><h4>Common mistakes engineers make</h4><p>🚫 Storing idempotency data in volatile caches<br>🚫 Using one key across multiple payment steps<br>🚫 Not validating request body against key (opens replay attacks)</p><h4>Fintech takeaway</h4><p>Idempotency isn’t a design choice — <br> 👉 <strong>it’s mandatory for all money-moving APIs.</strong></p><h3>3. Smart Retry Mechanisms: Retrying Without Double Charging</h3><p>Financial systems must retry aggressively because:</p><ul><li>networks drop</li><li>downstream services throttle</li><li>gateways timeout</li></ul><p>But <strong>bad retries = financial disasters</strong>, including:</p><ul><li>double charging</li><li>duplicate ACH transfers</li><li>repeated orders</li><li>retry storms that take entire systems down</li></ul><p>Smart retries prevent that.</p><h4>1. Exponential Backoff</h4><p>Instead of retrying instantly:</p><p><strong>1s → 2s → 4s → 8s → 16s …</strong></p><p>This prevents:</p><ul><li>system overload</li><li>thundering herd problems</li><li>cascading failures</li></ul><h4>2. Circuit Breakers</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/678/1*Qvj797BPMB6nnnWym8g3_Q.gif" /></figure><p>If a downstream service is failing:</p><p>🔌 <strong>Open the circuit</strong> → stop sending requests<br> 🔄 Allow the system to recover<br> 🟢 Close the circuit once healthy</p><p>This isolates failures and prevents meltdowns.</p><h4>3. Retry + Idempotency = Safety</h4><p>This is the golden rule:</p><p>👉 <strong>It is safe to retry only when the operation is idempotent.</strong></p><h3><strong>Conclusion</strong></h3><p>Moving money reliably means embracing the messy realities of real-world networks and failures. The most resilient fintech systems are built not on hope for perfection, but on proven engineering patterns — accepting trade-offs, preventing duplicates before they happen, and retrying smartly when things go wrong. Whether you’re building your first payment system or scaling high-frequency trading, mastering these reliability patterns is essential. They’re the foundation for delivering what matters most: money that moves quickly, securely, and always accurately.</p><h4>About the author</h4><p>Krizel Dias is a Mid Level Java Developer here at <a href="https://www.version1.com/">Version 1</a>.</p><p><strong>Further Reading &amp; Resources</strong></p><ul><li><em>Idempotency and APIs at Stripe — </em><a href="https://docs.stripe.com/api/idempotent_requests"><em>Stripe Docs</em></a></li><li><em>Exponential Backoff and Jitter — </em><a href="https://aws.amazon.com/builders-library/timeouts-retries-and-backoff-with-jitter/"><em>AWS Architecture Blog</em></a></li><li><em>Circuit Breaker Pattern — </em><a href="https://learn.microsoft.com/en-us/azure/architecture/patterns/circuit-breaker"><em>Microsoft Learn</em></a></li><li><em>Practical Microservices Patterns — </em><a href="https://microservices.io/"><em>microservices.io</em></a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5d4eee355b02" width="1" height="1" alt=""><hr><p><a href="https://medium.com/version-1/when-money-moves-the-reliability-patterns-that-power-modern-fintech-5d4eee355b02">When Money Moves: The Reliability Patterns That Power Modern Fintech</a> was originally published in <a href="https://medium.com/version-1">Version 1</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Monthly Microsoft License Update January 2026]]></title>
            <link>https://medium.com/version-1/monthly-microsoft-license-update-january-2026-8a2179284843?source=rss----3faaba3c731e---4</link>
            <guid isPermaLink="false">https://medium.com/p/8a2179284843</guid>
            <category><![CDATA[microsoft-365]]></category>
            <category><![CDATA[microsoft-azure]]></category>
            <category><![CDATA[microsoft-copilot]]></category>
            <dc:creator><![CDATA[Karl O’ Doherty]]></dc:creator>
            <pubDate>Mon, 02 Feb 2026 11:42:34 GMT</pubDate>
            <atom:updated>2026-02-02T11:41:41.359Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YCVw1sNNlQIOj4jqqTH9UA.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/@alesiaskaz">Alesia Kazantceva</a> on <a href="https://unsplash.com/">Unsplash</a></figcaption></figure><p>Need help understanding how these updates affect your Microsoft agreement?<em><br></em><a href="https://www.version1.com/contact/#form"><em>Talk to the Version 1 Microsoft Licensing Team</em></a></p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FwG7V_MF03gU%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DwG7V_MF03gU&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FwG7V_MF03gU%2Fhqdefault.jpg&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/32a891ad75b65806ead4d498bf706458/href">https://medium.com/media/32a891ad75b65806ead4d498bf706458/href</a></iframe><p><strong>Microsoft Defender Experts Suite</strong> — Updated terms to support the launch of Microsoft Defender Expert Suite, with updates to Availability table, License Prerequisite table and new purchasing minimums requirements.</p><p>Microsoft Defender Experts has two suites, Plan 1 and Plan 2</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/531/1*IMGHctVvnND5G1PYAH1qlA.png" /></figure><p>Pre-requisite for each licensed user includes:</p><p>· Microsoft 365 E5</p><p>· Microsoft Defender Suite</p><p>or</p><p>· Microsoft Defender and/or Purview Suite for Frontline Workers</p><p>There is a 66% discount promotion available until end of 2026 for qualifying customers, but no pricing has been released yet.</p><blockquote><a href="https://www.version1.com/software-asset-management/">Software Asset Management — Version 1</a></blockquote><p><strong>Price Harmonisation</strong> — There is a 7% decrease in the cost of end user CSP licenses from 1st February for Euro zone customers. This includes Microsoft 365, Dynamics 365, Power Platform and end user add-on subscriptions.</p><p><strong>Audio Services</strong> — Microsoft clarified that when you use their audio calling services (like Teams Phone), the actual phone numbers you use aren’t controlled by Microsoft, they’re managed by your telecom provider. So, if numbers are added, removed, or changed, that’s handled by the carrier through systems like Direct Routing or Operator Connect, not by Microsoft. Essentially, Microsoft provides the platform, but the carrier controls the phone numbers.</p><p><strong>Microsoft 365:</strong><em> </em>Security Copilot is now included with Microsoft 365 E5. A clause was added to specify the Microsoft 365 E5 subscription provides access to Security Copilot, along with a monthly allocation of Security Compute Units. Microsoft has rolled Security Copilot into Microsoft 365 E5 as of November 2025, with a monthly allocation of 400 Security Compute Units (unit measure of the compute power to run Security Copilot workloads) for every 1000 licenses, and up to 10,000 SCUs per tenant per month. If you have less than 1000 licenses, monthly SCUs are scaled down accordingly e.g. A customer with 400 user licenses gets 160 SCUs/month. Security Copilot was never a per-user license so customers without M365 E5 continue to purchase as usual under capacity-based pricing for provisioned SCUs (monthly billed) and overage SCUs (PAYG for extra usage).</p><p>Reference the Microsoft FAQ page for further details</p><p><strong>Visual Studio Licensing Guide</strong> — Microsoft has released an updated Visual Studio licensing guide (following its trend away from pdfs) to webpage format. Nothing has changed regarding editions and subscriptions, and its core licensing principles for environment use are steadfast. It is worth referencing if there is anything specific to your own usage scenario which should be checked is within the current use rights.</p><p><strong>Universal Terms for Online services, Privacy and Security Terms, Microsoft Azure and Glossary</strong> — Microsoft has just updated its AI product terms, and while the document is long, the changes boil down to a few important shifts.</p><p><strong>1.</strong> <strong>New platform focus<br> </strong>“First, Microsoft is repositioning <em>Azure AI Foundry</em> as Microsoft Foundry.<br> Foundry is now the main platform layer, with Azure AI services running <em>through</em> it, instead of standing alone.”</p><p><strong>2.</strong> <strong>Bing grounding is now a core Microsoft service</strong><br> “If you use Bing grounding for AI search, Microsoft now treats this as a first-party Microsoft service, governed by Bing’s enterprise legal terms.”</p><p><strong>3.</strong> <strong>Clear split between Microsoft and third-party models</strong><br> “Third-party models in Foundry are now officially classified as Non-Microsoft Products, <em>except</em> for a special group called Azure Direct Models.”</p><p><strong>4.</strong> <strong>Azure Direct Models are now tightly governed</strong><br> “These models fall under Microsoft’s main online services license.<br> Microsoft can:</p><p>o restrict access to specific models,</p><p>o temporarily store prompts and outputs,</p><ul><li>and review them to prevent abuse.”</li></ul><p><strong>5.</strong> <strong>Open-source models now have vendor-specific rules</strong><br> “Microsoft has added separate legal terms for models from Meta, xAI, DeepSeek, Mistral, OpenAI, and Alibaba — each with their own restrictions and enforcement rights.”</p><p><strong>6.</strong> <strong>High-risk AI features now require approval</strong><br> “Custom voice, face recognition, speaker recognition, and some AI avatars are now labelled Limited Access Services, meaning you must apply and be approved before use.”</p><p><strong>7.</strong> <strong>Synthetic voice and translation transparency</strong><br> “If you use synthetic voices, you must have written permission from the voice owner.<br> And if you show AI translations, you must label them as automatically translated by Microsoft.”</p><p>In conclusion Microsoft is moving toward stronger compliance, more model control, and tighter data oversight. If you build or deploy AI with Microsoft, these terms now directly affect how you can use and govern it.</p><h3>Need Help Navigating Microsoft Licensing?</h3><p>Whether you’re preparing for a renewal, adjusting your Azure usage, or scaling Copilot deployment — our team can guide you.</p><p>👉 <a href="https://www.version1.com/talk-to-us/">Speak with a Microsoft Licensing Consultant at Version 1</a></p><h3>About the Author</h3><p><strong>Karl O’Doherty</strong><br><em>Principal Licensing Consultant, Version 1</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8a2179284843" width="1" height="1" alt=""><hr><p><a href="https://medium.com/version-1/monthly-microsoft-license-update-january-2026-8a2179284843">Monthly Microsoft License Update January 2026</a> was originally published in <a href="https://medium.com/version-1">Version 1</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Aeron Archive in Practice: Recording and Replaying Streams in Java]]></title>
            <link>https://medium.com/version-1/aeron-archive-in-practice-recording-and-replaying-streams-in-java-ed798434645f?source=rss----3faaba3c731e---4</link>
            <guid isPermaLink="false">https://medium.com/p/ed798434645f</guid>
            <category><![CDATA[messaging]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[archive]]></category>
            <category><![CDATA[aeron]]></category>
            <dc:creator><![CDATA[Ryan McCauley]]></dc:creator>
            <pubDate>Mon, 02 Feb 2026 11:25:18 GMT</pubDate>
            <atom:updated>2026-02-02T11:25:17.096Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*vpiHPB_JgX7U-aij" /><figcaption>Photo by <a href="https://unsplash.com/@robinpierre?utm_source=medium&amp;utm_medium=referral">Robin Pierre</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p><strong>Aeron Archive</strong> is one of the most powerful components in the Aeron ecosystem. It allows you to record message streams and replay them later, enabling features such as durable messaging, time-based replays, and recovery for late-joining subscribers.</p><p>This article assumes you are already familiar with the basics of Aeron, including configuring the Media Driver and setting up publications and subscriptions. If you’d like a refresher, you can start with the previous article: <a href="https://medium.com/version-1/building-low-latency-messaging-with-aeron-in-java-cfe1d841d5d4">https://medium.com/version-1/building-low-latency-messaging-with-aeron-in-java-cfe1d841d5d4</a></p><p>We’ll begin by exploring the core components of Aeron Archive, examine relevant code from the demo project, and then get hands-on by running the demo to see how recording and replay work in practice.</p><blockquote><a href="https://www.version1.com/data-strategy-platforms-and-governance/">Data strategy, platforms and governance — Version 1</a></blockquote><h3>Aeron Archive Components</h3><p>The <strong>Aeron Archive</strong> is split into two main components: the <strong>Archive service</strong> and the <strong>Archive client</strong>.</p><p>For clarity, this article uses the term <strong>Archive service</strong> to distinguish it from the client. In Aeron’s own terminology, this component is simply referred to as the <strong>Aeron Archive</strong>.</p><p>The Archive service is responsible for persisting stream data, executing replays, and emitting events related to recording and replay progress. Like other Aeron components, it connects to a Media Driver.</p><p>The Archive does not intercept traffic inside the Media Driver. Instead, it records streams by subscribing to them in the same way as any other Aeron subscriber. From the Media Driver’s perspective, the Archive behaves just like a normal subscriber, consuming data from a channel and stream and writing it to persistent storage.</p><p>The Archive service itself is concerned with persisting stream data, while all interaction — such as starting and stopping recordings or initiating replays — is performed via the Archive client over a separate control channel.</p><p>The <strong>Archive client</strong> is responsible for issuing control requests to the Archive service, such as starting and stopping recordings and requesting replays.</p><p>In addition to sending requests, the Archive client listens for events emitted by the Archive service. These include notifications when recordings start or stop, along with metadata such as recording identifiers and the current recorded position.</p><p>The client sends requests to the Archive service to replay a recording and specify the channel and stream on which the replay should be published. While initiating a replay is done via the client, the replay itself is delivered as a normal Aeron publication from the Archive service to a subscription provided by the client. Replays are therefore indistinguishable from live publications from the perspective of the subscriber.</p><p>Now that we’ve covered the two main components of the <strong>Aeron Archive</strong>, we’ll move on to how to configure the Archive service and client.</p><h3>Archive Configuration</h3><p>One of the biggest hurdles when working with Aeron Archive is understanding how to configure both the <strong>Archive service</strong> and the <strong>Archive client</strong>. Compared to regular publications and subscriptions, there are additional channels and setup steps required.</p><p>In this section, we’ll walk through the configuration of both components. Later, in the code walkthrough, we’ll look at how these configurations are applied in practice.</p><h4>Archive Service Configuration</h4><p>The Archive service configuration introduces several additional channels beyond those used for regular publications and subscriptions. At a high level, the configuration breaks down as follows:</p><p><strong>control channel</strong> — Consists of a channel and stream ID. The Archive service opens a subscription on this channel and polls for requests from the Archive client. Archive clients must be configured to send control requests to this channel.</p><p><strong>recording events channel — </strong>Used by the Archive service to publish recording-related events to clients, such as when a recording starts or stops, along with associated metadata.</p><p><strong>replication channel — </strong>Used by the Archive for replicating recordings between archive instances. This is primarily used for archive-to-archive replication and is not required for basic recording and replay scenarios.</p><h4>Archive Client Configuration</h4><p>The Archive client introduces several additional configuration options in order to communicate with the Archive service.</p><p><strong>control request channel — </strong>Used by the client to send control requests to the Archive service, such as starting or stopping recordings and initiating replays.</p><p><strong>recording events channel — </strong>The channel on which the client receives recording-related events from the Archive service. This must match the Archive service’s configured recordingEventsChannel.</p><p><strong>control response channel — </strong>Used by the Archive service to send responses to control requests issued by the client. The client subscribes to this channel to receive control responses and status information.</p><h3>Code Walkthrough</h3><p>Two additional modules have been added to the demo to support archiving:</p><ul><li><strong>archive</strong> — runs the Archive service, which persists messages and receives control requests from the Archive client</li><li><strong>archive-client</strong> — runs the Archive client, which interacts with the Archive service to request recordings and initiate replays</li></ul><p>As with the previous demo, Aeron-specific logic is isolated within the aeron packages. Code outside these packages is primarily responsible for wiring and starting the services and does not require any Aeron-specific knowledge.</p><p>We’ll begin by looking at the Archive service.</p><h4>archive</h4><p>There is only one class of interest containing the aeron archive logic:</p><p>io.ryanjames.aeron.AeronArchive</p><pre>public synchronized void startArchive(String mediaDriverPath, String controlChannel, String recordingEventsChannel) {<br>    Archive.Context aeronContext = new Archive.Context()<br>            .aeronDirectoryName(mediaDriverPath)<br>            .controlChannel(controlChannel)<br>            .recordingEventsChannel(recordingEventsChannel)<br>            .replicationChannel(&quot;aeron:udp?endpoint=localhost:0&quot;)<br>            .recordingEventsEnabled(true);<br>...</pre><p><strong>Explanation:<br></strong>Here we see a familiar pattern: configuring a context, this time using Archive.Context.</p><p>Under the hood, the Archive service connects to the Media Driver and creates subscriptions based on this configuration. As a result, the first required setting is the aeronDirectoryName, which points the Archive at the local Media Driver instance.</p><p>Next are the channels discussed earlier. Enabling recordingEventsEnabled allows the Archive service to emit recording-related events—such as when a recording starts or stops—on the configured recordingEventsChannel. In this demo, the recordingEventsChannel uses an MDC channel, allowing Archive clients to dynamically subscribe and receive events. This also means multiple Archive clients can listen for recording events concurrently.</p><p>The remaining configuration is the replicationChannel. In this case, it is safe to hardcode the channel and use port 0, allowing Aeron to select an available port. This channel is only required on the Archive service side and is used for archive-to-archive replication; the replication destination does not need prior knowledge of this channel.</p><p>Once the context has been configured, the remaining work is simply to launch the Archive service.</p><pre>try {<br>    aeronArchive = Archive.launch(aeronContext);<br>    LOGGER.info(&quot;Aeron Archive started (aeronDir={}, controlChannel={}, recordingEventsChannel={})&quot;, mediaDriverPath,<br>            controlChannel, recordingEventsChannel);<br>} catch (Exception e) {<br>    LOGGER.error(&quot;Failed to launch Aeron Archive&quot;, e);<br>    throw new IllegalStateException(&quot;Unable to start Aeron Archive&quot;, e);<br>}</pre><p>Once the context has been configured, launching the Archive service is straightforward. Calling Archive.launch(...) starts the Archive and connects it to the configured Media Driver.</p><p>At this point, the Archive service is running and ready to receive control requests from Archive clients via the configured control channel.</p><h4>archive-client</h4><p>Next we will look at the archive client code. Again the interesting aeron code is isolated in a single class</p><p>io.ryanjames.aeron.AeronClient</p><pre>public synchronized void connect(String mediaDriverPath, String controlRequestChannel,<br>                                 String recordingEventsChannel,<br>                                 String controlResponseChannel) {<br>    AeronArchive.Context aeronContext = new AeronArchive.Context()<br>            .aeronDirectoryName(mediaDriverPath)<br>            .controlRequestChannel(controlRequestChannel)<br>            .recordingEventsChannel(recordingEventsChannel)<br>            .controlResponseChannel(controlResponseChannel)<br>            .recordingSignalConsumer(this);</pre><p><strong>Explanation:</strong><br>Following a similar pattern to the Archive service, the Archive client is configured using a context. Like other Aeron components, it requires access to the Media Driver, so the first step is to point it at the appropriate Aeron directory.</p><p>The controlRequestChannel is then configured to match the Archive service’s controlChannel. This allows the client to publish control requests—such as starting or stopping recordings and initiating replays—to the Archive service.</p><p>The recordingEventsChannel is used to receive recording-related events emitted by the Archive service. In addition to configuring the channel, we also supply a recordingSignalConsumer, which allows the client to handle these events programmatically. We’ll look at this in more detail shortly.</p><p>Finally, the controlResponseChannel is configured. The Archive client opens a subscription on this channel to receive responses to control requests issued to the Archive service.</p><p>Next, we’ll look at how the Archive client receives recording events via the RecordingSignalConsumer.</p><pre>public class AeronClient implements AutoCloseable, RecordingSignalConsumer<br>...<br>    public void poll() {<br>        if (isRunning()) {<br>            archiveClient.pollForRecordingSignals();<br>        }<br>    }<br>...<br>    @Override<br>    public void onSignal(long controlSessionId, long correlationId, long recordingId, long subscriptionId, long position, RecordingSignal signal) {<br>        LOGGER.info(&quot;Received recording signal: controlSessionId={}, correlationId={}, recordingId={}, subscriptionId={}, position={}, signal={}&quot;,<br>                controlSessionId, correlationId, recordingId, subscriptionId, position, signal);<br>    }</pre><p>The AeronClient implements the RecordingSignalConsumer interface, which allows it to receive recording-related signals emitted by the Archive service. These signals include notifications such as when a recording starts or stops, along with associated metadata like recording identifiers and positions.</p><p>In this example, the onSignal callback simply logs the received information. In a real production system, however, these signals can be used for more meaningful purposes—for example, tracking available recordings, updating application state, or persisting metadata for later replay.</p><p>Implementing the RecordingSignalConsumer alone is not sufficient. As with all Aeron interactions, recording signals are delivered via polling. This gives the application explicit control over when and how events are processed.</p><p>To handle this, the client polls for recording signals on a background thread:</p><pre>executor.submit(() -&gt; {<br>    while (!Thread.currentThread().isInterrupted()) {<br>        int work = archiveClient.pollForRecordingSignals();<br>        idle.idle(work);<br>    }<br>});</pre><p>Starting a recording is straightforward:</p><pre>public long startRecording(String channel, int streamId) {<br>    long subscriptionId = archiveClient.startRecording(channel, streamId, SourceLocation.LOCAL);<br>    LOGGER.info(&quot;Started recording subscriptionId={} channel=&#39;{}&#39; streamId={}&quot;, subscriptionId, channel, streamId);<br>    return subscriptionId;<br>}</pre><p>Calling startRecording sends a control request to the Archive service via the control request channel, instructing it to begin recording the specified channel and stream.</p><p>The Archive service responds to this request over the client’s control response channel, allowing the call to complete. Separately, the Archive service emits recording signals — such as a recording start notification — on the recording events channel. These signals are delivered asynchronously and can be processed by polling via the RecordingSignalConsumer.</p><p>Once a stream has been recorded, the next step is to replay it:</p><pre>public void replay(long recordingId, String channel, int streamId) {<br>    long replaySessionId = archiveClient.startReplay(recordingId, channel, streamId, new ReplayParams());<br>    LOGGER.info(&quot;Started replay of recordingId={} to channel=&#39;{}&#39; streamId={} and replaySessionId: {}&quot;, recordingId, channel, streamId,<br>            replaySessionId);<br>}</pre><p>It’s important to note that the channel and streamId provided here are <strong>not</strong> the original channel and stream that were recorded. Instead, they define where the replayed data will be published.</p><p>The recordingId uniquely identifies the recorded stream and tells the Archive service what data should be replayed. The Archive service publishes the replay as a normal Aeron publication on the specified channel and stream, and the Archive client creates a subscription to receive the replayed data.</p><h3>Demo Walkthrough</h3><p>Now that we have a good understanding of the <strong>Aeron Archive</strong> we will jump into a short demo to see it in action. To begin clone the project <a href="https://github.com/k4pran/Aeron-Demo">https://github.com/k4pran/Aeron-Demo</a>.</p><p>We first need to run the non-archive services as we will want to record a publication. Starting these next three services will be mostly a condensed form of the previous article, but for more detail on these components read the demo at <a href="https://medium.com/version-1/building-low-latency-messaging-with-aeron-in-java-cfe1d841d5d4">https://medium.com/version-1/building-low-latency-messaging-with-aeron-in-java-cfe1d841d5d4</a></p><p><strong>Starting the </strong>client-mediadriver</p><p>1. Run ./gradlew client-mediadriver:run <br>2. Check the logs</p><pre>17:18:54.002 [main] INFO  io.javalin.Javalin - Javalin started in 283ms \o/<br>17:18:54.002 [main] INFO  io.javalin.Javalin - Listening on http://localhost:7000/<br>17:18:54.009 [main] INFO  io.javalin.Javalin - You are running Javalin 6.7.0 (released June 22, 2025. Your Javalin version is 211 days old. Consider checking for a newer version.).<br>17:18:54.009 [main] INFO  io.ryanjames.MediaDriverService - Redoc docs served at http://localhost:7000/redoc<br>17:18:54.009 [main] INFO  io.ryanjames.MediaDriverService - Swagger UI served at http://localhost:7000/swagger</pre><p>3. Navigate to url <a href="http://localhost:7000/swagger">http://localhost:7000/swagger</a><br>4. Start the MediaDriver with the directory path <strong>../aeron</strong>. Aeron will then create a directory at the project level</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SdRgMsTy0kLisOUogd-FsQ.png" /><figcaption>Start the mediadriver with REST request at <a href="http://localhost:7000/mediadriver/start"><strong>http://localhost:7000/mediadriver/start</strong></a></figcaption></figure><p><strong>Preparing the order-entry-client</strong></p><p>1. Run ./gradlew order-entry-client:run <br>2. Check the logs</p><pre>17:19:31.063 [main] INFO  io.javalin.Javalin - Javalin started in 276ms \o/<br>17:19:31.063 [main] INFO  io.javalin.Javalin - Listening on http://localhost:7001/<br>17:19:31.078 [main] INFO  io.javalin.Javalin - You are running Javalin 6.7.0 (released June 22, 2025. Your Javalin version is 211 days old. Consider checking for a newer version.).<br>17:19:31.078 [main] INFO  io.ryanjames.OrderEntryService - Redoc docs served at http://localhost:7001/redoc<br>17:19:31.078 [main] INFO  io.ryanjames.OrderEntryService - Swagger UI served at http://localhost:7001/swagger</pre><p>3. Navigate to <a href="http://localhost:7001/swagger">http://localhost:7001/swagger</a><br>4. Connect to the MediaDriver using the same directory we started the MediaDriver with — <strong>../aeron</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Kz0Ar-TFNd3goM9I-ztghQ.png" /><figcaption>Connect the client with REST request at <a href="http://localhost:7001/client/connect"><strong>http://localhost:7001/client/connect</strong></a></figcaption></figure><p>Create a UDP publication with the /client/addPublication endpoint with the following parameters:</p><ul><li>channel = aeron:udp?endpoint=localhost:40000</li><li>streamId = 10</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*g0Az6E0XIOdgA-sUYe0ghw.png" /><figcaption>Add publication with REST endpoint — <a href="http://localhost:7001/client/addPublication"><strong>http://localhost:7001/client/addPublication</strong></a></figcaption></figure><p><strong>Preparing the order-gateway-server</strong></p><p>Next we follow similar steps to initialize the order entry client. Remember we use an <strong>embedded MediaDriver </strong>for this service that will start automatically, that gives us one less step.</p><p>1. Run ./gradlew order-gateway-server:run <br>2. Check the logs</p><pre>17:22:29.054 [main] INFO  io.javalin.Javalin - Javalin started in 191ms \o/<br>17:22:29.057 [main] INFO  io.javalin.Javalin - Listening on http://localhost:7002/<br>17:22:29.068 [main] INFO  io.javalin.Javalin - You are running Javalin 6.7.0 (released June 22, 2025. Your Javalin version is 211 days old. Consider checking for a newer version.).<br>17:22:29.068 [main] INFO  io.ryanjames.OrderGatewayService - Redoc docs served at http://localhost:7002/redoc<br>17:22:29.068 [main] INFO  io.ryanjames.OrderGatewayService - Swagger UI served at http://localhost:7002/swagger</pre><p>3. Navigate to <a href="http://localhost:7002/swagger">http://localhost:7002/swagger</a><br>4. Create a subscription</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*I5mCBej4stp27fiQa4GpzA.png" /><figcaption>Create a subscription listening on the same channel and stream as the publication with REST endpoint <a href="http://localhost:7002/gateway/addSubscriber"><strong>http://localhost:7002/gateway/addSubscriber</strong></a></figcaption></figure><p>Now that we have the three original services running we can next prepare the two components involved in archiving</p><p><strong>Preparing the archive service</strong></p><p>1. Run ./gradlew archive:run <br>2. Check the logs</p><pre>17:24:24.000 [main] INFO  io.javalin.Javalin - Javalin started in 251ms \o/<br>17:24:24.003 [main] INFO  io.javalin.Javalin - Listening on http://localhost:7003/<br>17:24:24.013 [main] INFO  io.javalin.Javalin - You are running Javalin 6.7.0 (released June 22, 2025. Your Javalin version is 211 days old. Consider checking for a newer version.).<br>17:24:24.013 [main] INFO  io.ryanjames.ArchiveApplication - Redoc docs served at http://localhost:7003/redoc<br>17:24:24.013 [main] INFO  io.ryanjames.ArchiveApplication - Swagger UI served at http://localhost:7003/swagger</pre><p>3. Navigate to <a href="http://localhost:7003/swagger">http://localhost:7003/swagger</a><br>4. Start the archive</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*S8D6BWwEUx_e8ymu9A5KAQ.png" /><figcaption>Start the archive with REST endpoint <a href="http://localhost:7003/archive/start"><strong>http://localhost:7003/archive/start</strong></a></figcaption></figure><p>The parameters we are using are:</p><ul><li><strong>aeron directory path — </strong>../aeron</li><li><strong>archive control channel — </strong>aeron:udp?endpoint=0.0.0.0:4400</li><li><strong>archive recording events channel — </strong>aeron:udp?control-mode=dynamic|control=localhost:4401</li></ul><p>The recording events channel can look a little daunting so let’s break it down.</p><p>This channel uses <strong>Aeron’s Multi-Destination Cast (MDC)</strong> in dynamic control mode. Rather than publishing to a single fixed endpoint, the Archive service publishes recording events to a logical channel, and interested clients dynamically register themselves as destinations.</p><p>The control=localhost:4401 endpoint acts as the MDC control address. Archive clients send control messages to this address to join the channel, after which the Archive service begins sending recording events to them. This allows multiple Archive clients to subscribe to recording events without requiring the Archive service to be reconfigured for each client and the archive doesn’t need to know the client recording channels in order to publish to them.</p><p><strong>Preparing the archive client</strong></p><p>1. Run ./gradlew archive-client:run <br>2. Check the logs</p><pre>17:32:08.714 [main] INFO  io.javalin.Javalin - Javalin started in 258ms \o/<br>17:32:08.717 [main] INFO  io.javalin.Javalin - Listening on http://localhost:7004/<br>17:32:08.731 [main] INFO  io.javalin.Javalin - You are running Javalin 6.7.0 (released June 22, 2025. Your Javalin version is 211 days old. Consider checking for a newer version.).<br>17:32:08.731 [main] INFO  i.ryanjames.ArchiveClientApplication - Redoc docs served at http://localhost:7004/redoc<br>17:32:08.731 [main] INFO  i.ryanjames.ArchiveClientApplication - Swagger UI served at http://localhost:7004/swagger</pre><p>3. Navigate to <a href="http://localhost:7004/swagger">http://localhost:7004/swagger</a><br>4. Start the archive client</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3px3hDjGj2NyALvUvBcCvw.png" /><figcaption>Start the archive client with REST endpoint <a href="http://localhost:7004/archive/client/connect"><strong>http://localhost:7004/archive/client/connect</strong></a></figcaption></figure><p>The parameters we are using here are:</p><ul><li><strong>aeron directory path — </strong>../aeron</li><li><strong>control request channel — </strong>aeron:udp?endpoint=localhost:4400</li><li><strong>recording events channel — </strong>aeron:udp?control-mode=dynamic|control=localhost:4401</li><li><strong>control response channel</strong> — aeron:udp?endpoint=localhost:0</li></ul><p><strong>Recording and Replaying</strong></p><p>Now that we have all our pieces set up, our next steps are:</p><ol><li>Start a recording on the publication we started earlier</li><li>Publish a few messages</li><li>Replay the messages to a new channel</li></ol><p>First we want to begin recording the publication channel.</p><p><strong>Start a recording</strong></p><ol><li>Navigate to the archive-client at <a href="http://localhost:7004/swagger">http://localhost:7004/swagger</a></li><li>Start a recording using the publication’s channel</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vzGyR3B3R9zfW-mYSsuvtA.png" /><figcaption>Start a recording with REST endpoint <a href="http://localhost:7004/archive/client/record"><strong>http://localhost:7004/archive/client/record</strong></a></figcaption></figure><p>3. Check the archive-client logs</p><pre>17:41:04.334 [pool-1-thread-1] INFO  io.ryanjames.aeron.AeronClient - Received recording signal: controlSessionId=1707056815, correlationId=34, recordingId=11, subscriptionId=35, position=0, signal=START</pre><p><strong>Publish a few messages</strong></p><ol><li>Navigate to the order-entry-client at <a href="http://localhost:7001/swagger">http://localhost:7001/swagger</a></li><li>Publish a few messages, remember that we pass the registrationId which you can find in the order-entry-client logs.</li></ol><pre>17:21:58.091 [JettyServerThreadPool-20] INFO  io.ryanjames.aeron.AeronClient - Publication &#39;2&#39; created with channel &#39;aeron:udp?endpoint=localhost:40000&#39;, streamId &#39;10&#39;</pre><p>In my case my registrationId is <strong>2</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GnP5Zz5d-C7gdMBr9HEPPQ.png" /><figcaption>Publish message with REST endpoint <a href="http://localhost:7001/client/publishMessage"><strong>http://localhost:7001/client/publishMessage</strong></a></figcaption></figure><p>3. As a sanity check we can validate our messages have been received by the subscription we set up earlier in the order-gateway-server logs</p><pre>17:49:03.584 [aeron-subscriber-aeron:udp?endpoint=localhost:40000-10] INFO  i.r.aeron.AeronSubscriberService - received: Test message 1<br>17:50:31.517 [aeron-subscriber-aeron:udp?endpoint=localhost:40000-10] INFO  i.r.aeron.AeronSubscriberService - received: Test message 2<br>17:50:34.302 [aeron-subscriber-aeron:udp?endpoint=localhost:40000-10] INFO  i.r.aeron.AeronSubscriberService - received: Test message 3</pre><p><strong>Create a subscription for the replayer</strong></p><ol><li>Create another subscriber in the order-gateway-service same as we did before, but this time we are creating a subscription that will receive the replayed data</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zpTB9CHp2W9tIYnUzsv2Nw.png" /><figcaption>Create a subscription listening on the same channel and stream as we will replay to with REST endpoint <a href="http://localhost:7002/gateway/addSubscriber"><strong>http://localhost:7002/gateway/addSubscriber</strong></a></figcaption></figure><p><strong>Replay the stream</strong></p><ol><li>Navigate to the archive-client at <a href="http://localhost:7004/swagger">http://localhost:7004/swagger</a></li><li>Check the logs for the recordingId</li></ol><pre>17:41:04.334 [pool-1-thread-1] INFO  io.ryanjames.aeron.AeronClient - Received recording signal: controlSessionId=1707056815, correlationId=34, recordingId=11, subscriptionId=35, position=0, signal=START</pre><p>In my case the recordingId is <strong>11</strong></p><p>3. Start the replay</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tZiCMKCi2uXv4f_zEAV7-g.png" /><figcaption>Replay a recording with REST endpoint <a href="http://localhost:7004/archive/client/replay"><strong>http://localhost:7004/archive/client/replay</strong></a></figcaption></figure><p>4. Check logs for the order-gateway-server to check the stream was replayed</p><pre>17:55:30.932 [JettyServerThreadPool-25] INFO  i.r.aeron.AeronSubscriberService - Subscriber created with channel &#39;aeron:udp?endpoint=localhost:5000&#39;, streamId &#39;10&#39; and registrationId &#39;4&#39;<br>17:55:59.010 [aeron-subscriber-aeron:udp?endpoint=localhost:5000-10] INFO  i.r.aeron.AeronSubscriberService - received: Test message 1<br>17:55:59.010 [aeron-subscriber-aeron:udp?endpoint=localhost:5000-10] INFO  i.r.aeron.AeronSubscriberService - received: Test message 2<br>17:55:59.010 [aeron-subscriber-aeron:udp?endpoint=localhost:5000-10] INFO  i.r.aeron.AeronSubscriberService - received: Test message 3</pre><p>Notice too that it will be replayed in the order it was sent, we can replay again and it again will replay the recording from the beginning, or even replay to another subscriber</p><pre>17:55:59.010 [aeron-subscriber-aeron:udp?endpoint=localhost:5000-10] INFO  i.r.aeron.AeronSubscriberService - received: Test message 1<br>17:55:59.010 [aeron-subscriber-aeron:udp?endpoint=localhost:5000-10] INFO  i.r.aeron.AeronSubscriberService - received: Test message 2<br>17:55:59.010 [aeron-subscriber-aeron:udp?endpoint=localhost:5000-10] INFO  i.r.aeron.AeronSubscriberService - received: Test message 3<br>18:01:53.939 [aeron-subscriber-aeron:udp?endpoint=localhost:5000-10] INFO  i.r.aeron.AeronSubscriberService - received: Test message 1<br>18:01:53.939 [aeron-subscriber-aeron:udp?endpoint=localhost:5000-10] INFO  i.r.aeron.AeronSubscriberService - received: Test message 2<br>18:01:53.939 [aeron-subscriber-aeron:udp?endpoint=localhost:5000-10] INFO  i.r.aeron.AeronSubscriberService - received: Test message 3</pre><h3>What’s Next?</h3><p>This article provides a practical introduction to the Aeron Archive and demonstrates the core record-and-replay workflow. However, it only scratches the surface of what the Archive is capable of.</p><p>Beyond the basics, the Aeron Archive supports a number of more advanced patterns and features, including:</p><ul><li><strong>Multiple concurrent clients</strong><br>Multiple Archive clients can interact with the same Archive service, allowing different applications or tools to start recordings, monitor recording progress, and initiate replays independently.</li><li><strong>Archive-to-archive replication</strong><br>Recordings can be replicated between Archive instances, enabling redundancy, migration, or disaster-recovery scenarios or syncing multiple hosts.</li><li><strong>Partial and position-based replays</strong><br>Replays are not limited to starting from the beginning of a recording. The Archive allows recordings to be replayed from specific positions, making it possible to resume processing and rebuild state and replay only what was missed.</li><li><strong>Remote replays</strong><br>Replays can be published to channels on remote hosts, allowing recorded data to be streamed across machines or environments just like regular aeron streams.</li></ul><p>These capabilities make the Aeron Archive a powerful building block for systems that require low-latency messaging while still supporting durability, recovery, and operational flexibility. If you’re interested in going beyond the basics, each of these areas is well worth exploring further.</p><h3>Conclusion</h3><p>In this article, we explored the Aeron Archive and how it extends Aeron’s low-latency messaging model with durable recording and replay capabilities. By walking through the core components, configuration, and a hands-on demo, we’ve seen how recordings and replays fit naturally into existing Aeron applications. While this only covers the fundamentals, it should provide a solid foundation for using the Archive in practice and for exploring its more advanced features going forward.</p><h3>About the author</h3><p>Ryan McCauley is a Senior Software Engineer here at <a href="https://www.version1.com/">Version 1</a>.</p><h3>Resources</h3><p><strong>Start here</strong></p><ul><li><a href="https://aeron.io/">https://aeron.io/ </a>— official site</li><li><a href="https://aeron.io/docs/aeron/overview/">https://aeron.io/docs/aeron/overview/ </a>— Aeron overview</li><li><a href="https://aeron.io/docs/aeron-archive/overview/">https://aeron.io/docs/aeron-archive/overview/</a> — Aeron archive overview</li></ul><p><strong>Previous article</strong></p><ul><li><a href="https://medium.com/version-1/building-low-latency-messaging-with-aeron-in-java-cfe1d841d5d4">https://medium.com/version-1/building-low-latency-messaging-with-aeron-in-java-cfe1d841d5d4</a></li></ul><p><strong>Demo Project</strong></p><ul><li><a href="https://github.com/k4pran/Aeron-Demo">https://github.com/k4pran/Aeron-Demo</a> — <strong>GitHub Demo Project</strong></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ed798434645f" width="1" height="1" alt=""><hr><p><a href="https://medium.com/version-1/aeron-archive-in-practice-recording-and-replaying-streams-in-java-ed798434645f">Aeron Archive in Practice: Recording and Replaying Streams in Java</a> was originally published in <a href="https://medium.com/version-1">Version 1</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AI Adoption Is Easy — Creating Value is the Hard Part]]></title>
            <link>https://medium.com/version-1/ai-adoption-is-easy-creating-value-is-the-hard-part-0c9042478d63?source=rss----3faaba3c731e---4</link>
            <guid isPermaLink="false">https://medium.com/p/0c9042478d63</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[organisational-design]]></category>
            <category><![CDATA[adoption]]></category>
            <category><![CDATA[change-management]]></category>
            <dc:creator><![CDATA[Joanita Radivoev]]></dc:creator>
            <pubDate>Wed, 21 Jan 2026 12:48:39 GMT</pubDate>
            <atom:updated>2026-01-21T12:48:32.952Z</atom:updated>
            <content:encoded><![CDATA[<h3>AI Adoption Is Easy — Creating Value is the Hard Part</h3><p>AI adoption looks healthy on the surface. Pilots are running, you have rolled out tools and cannot keep up with the training demand. Your Executives reference the impressive AI demos they have seen, a number of proof-of-concepts are up and running and the early adopters are enthusiastic.</p><p>But, months later the numbers tell a different story. Delivery is not faster. Costs have not shifted and margins look the same. Any productivity gains are anecdotal at best.</p><p>This is not because AI does not work. It is often because organisations did not consider how to absorb productivity.</p><blockquote><a href="https://www.version1.com/blog/laying-the-foundations-why-most-ai-projects-fail-before-they-start/">Laying the foundations: Why most AI projects fail before they start — Version 1</a></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*cNF6gqkzUVK-euhG" /><figcaption>Photo by <a href="https://unsplash.com/@boliviainteligente?utm_source=medium&amp;utm_medium=referral">BoliviaInteligente</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p><strong>The Illusion of AI Progress</strong></p><p>In many organisations, AI progress is measured by activity:</p><ul><li>Number of tools rolled out</li><li>Number of people trained</li><li>Number of pilots launched</li></ul><p>Eric Ries (The Lean Startup) calls it “vanity metrics” — numbers that make us feel good, but don’t drive better decisions.</p><p>These AI activity metrics create the <em>appearance</em> of momentum — but very little changes in how work is actually delivered. This results in a very familiar picture — pilots everywhere (“pilot purgatory”), but no systemic impact on cost, speed, or quality.</p><p>Instead of AI being something the organisation runs on, it just stays the thing that teams occasionally <em>experiment with.</em></p><p><strong>The New Year’s Resolution Problem</strong></p><p>At the beginning of a new year, we all make resolutions. You may have experienced it over the last two weeks — gyms are crowded and new gym memberships are selling like hotcakes. Personal Trainers can’t keep up with all their appointments.</p><p>But then February comes along. Most of those memberships are unused.</p><p>This does not happen because the gym is bad, the equipment doesn’t work or people don’t know how to exercise. It happens because most of us don’t change our daily routines, nothing forces us to be consistent, and we don’t really measure progress in a way that matters.</p><p>As James Clear puts it in Atomic Habits:</p><blockquote><strong>“You do not rise to the level of your goals. You fall to the level of your systems.” </strong>James Clear (Atomic Habits)</blockquote><p>AI adoption fails for the same reason. The goal is clear; the tools are available — but the organisational system does not change. We buy the tools, run pilots and train people. And still our organisational habits stays the same.</p><p>Most systems reward effort over efficiency. We don’t change the way we work or how we reward people. Most of all any productivity gains from AI is not tracked or absorbed. And for this reason, using AI is like going to gym in January. We use it sporadically (when it feels safe or convenient), but it does not become our default way of working.</p><p><strong>Why “AI Training + Tools” Is Not Working</strong></p><p>I have seen strategies that assume AI adoption is a simple equation:</p><p><strong>Give people tools + train them → productivity will improve</strong></p><p>The problem with this strategy is that there is an assumption that productivity lives at the individual level. But, productivity lives in systems. Even if AI makes people faster:</p><ul><li>Delivery models still bill by hours</li><li>Estimates still assume old effort levels</li><li>Utilisation targets still reward busyness</li><li>Governance still treats AI as risky and optional</li></ul><p>We all want the superpowers that AI can give us. We experiment with AI and use AI where it helps us personally. But we also avoid anything that creates risks (or even the perception of risk).</p><p><strong>Why Adoption Is Uneven </strong><em>(And Always Will Be Without Design Change)</em></p><p>I have been involved in several AI implementations across different industries. AI adoption is never even. It always clusters in some areas and stalls in others. Some of the reasons for this uneven adoption include:</p><p><strong>Workflow “AI-Fit”</strong></p><p>AI fits easily into high-volume, repeatable, digitised workflows. But it really struggles with ambiguous, bespoke, relationship-heavy work or poorly defined or undocumented processes. Adoption follows where AI <em>fits</em>, not where value is highest.</p><p><strong>Leadership Pull</strong></p><p>Where leaders actively encourage and role-model AI use, adoption grows. But in areas where AI is “optional,” it remains peripheral. People follow role models, not organisational communications or fancy slide decks.</p><p><strong>Fear and Risk Perception</strong></p><p>Concerns around job erosion, quality failures, customer data and IP, as well as regulatory exposure stops people from using AI. These are not irrational fears. But if there are no clear guardrails, people will default to caution.</p><p><strong>What Needs to Change</strong></p><p>The answer is not more pilots or more tools or even more training. What needs to change is the operating model.</p><p>Organisations need:</p><ul><li>Clear ownership for productivity outcomes</li><li>Standardised, AI-enabled ways of working</li><li>Measurement that connects AI use to delivery and financial metrics</li><li>Incentives that reward throughput, quality, and predictability</li><li>Governance that enables speed instead of paralysing it</li></ul><p>In other words, AI must be treated as a delivery discipline, not a technology experiment.</p><p><strong>The Bottom Line</strong></p><p>AI doesn’t fail because people resist it. It fails because organisations are structured to hide productivity, not realise it. Until that changes, AI will continue to look promising — and deliver very little.</p><p>As W. Edwards Deming the father of Productivity &amp; Continuous Improvement) put it:</p><blockquote><strong>“Every system is perfectly designed to get the results it gets.”</strong></blockquote><blockquote><em>W. Edwards Deming</em></blockquote><h3>About the author</h3><p>Joanita Radivoev is a Delivery Manager here at <a href="https://www.version1.com/">Version 1</a>.</p><h4><strong>References</strong></h4><p>The Lean Startup — Eric Ries</p><p>Atomic Habits — James Clear</p><p><a href="https://medium.com/@bruvajc/95-of-genai-pilots-fail-heres-why-and-how-to-avoid-it-and-ai-pilot-purgatory-c3a860787780">95% of GenAI Pilots Fail — Here’s Why (and How to Avoid It and ‘AI Pilot Purgatory’) | by John The CEO, AI-Enabled Solution Strategist | Medium</a></p><p><a href="https://www.version1.com/blog/why-90-of-ai-pocs-fail-and-how-modelops-can-save-them/">Why 90% of AI PoCs fail and how ModelOps can save them — Version 1</a></p><p><a href="https://hbr.org/2025/01/why-people-resist-embracing-ai">Why People Resist Embracing AI</a></p><p><a href="https://deming.org/explore/fourteen-points/">Dr. Deming’s 14 Points for Management — The W. Edwards Deming Institute</a></p><p><a href="https://www.gartner.com/en/insights">Gartner Business Insights, Strategies &amp; Trends For Executives</a></p><p><a href="https://www.mckinsey.com/capabilities/quantumblack/our-insights/the-state-of-ai">The State of AI: Global Survey 2025 | McKinsey</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0c9042478d63" width="1" height="1" alt=""><hr><p><a href="https://medium.com/version-1/ai-adoption-is-easy-creating-value-is-the-hard-part-0c9042478d63">AI Adoption Is Easy — Creating Value is the Hard Part</a> was originally published in <a href="https://medium.com/version-1">Version 1</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to Get the Best Out of Your AI Code Assistant]]></title>
            <link>https://medium.com/version-1/how-to-get-the-best-out-of-your-ai-code-assistant-0b89d01b2869?source=rss----3faaba3c731e---4</link>
            <guid isPermaLink="false">https://medium.com/p/0b89d01b2869</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[developer-productivity]]></category>
            <category><![CDATA[ai-tools]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[prompt-engineering]]></category>
            <dc:creator><![CDATA[Alana Barrett-Frew]]></dc:creator>
            <pubDate>Wed, 21 Jan 2026 12:35:42 GMT</pubDate>
            <atom:updated>2026-01-21T12:35:41.462Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BJdLUe0Yg8sV3diaUX9hFA.png" /></figure><p>After a year of using GitHub Copilot daily - watching it evolve from basic autocomplete to chat to full agent mode - I&#39;ve learned something crucial: the difference between developers who get great results from AI and those who don&#39;t isn&#39;t about the tool. It&#39;s about how you use it.</p><p>I spent 20 years as a teacher - maths, geography, PE, animal care - which taught me that breaking down complex problems into manageable steps is fundamental to learning anything. When I moved into development, that same principle applied. And now, working with AI assistants, it&#39;s more relevant than ever: the better you can articulate what you need, the better the results you&#39;ll get.</p><p>Here&#39;s what I&#39;ve learned from building production applications with AI assistance, including a government project where I used Copilot to write consistent Angular code and Playwright tests. These aren&#39;t theoretical tips - they&#39;re techniques I use every day.</p><blockquote><a href="https://www.version1.com/blog/prompting-gpt-5/">Prompting GPT-5 — Version 1</a></blockquote><h3>The AI Adoption Challenge</h3><p>Your colleague asks an AI assistant to build an authentication system and gets production-ready code in minutes. You ask the same assistant for the same thing and get something that barely compiles. Sound familiar?</p><p>This isn’t just frustrating, it’s holding back AI adoption across entire organisations. Here’s what I see repeatedly:</p><p><strong>Inconsistent Results:</strong> Developers get vastly different quality outputs depending on their prompts. Some copy-paste code without understanding what it does or whether it’s even correct.</p><p><strong>No Shared Standards:</strong> Each team develops their own approach, some embrace AI assistants, others avoid them entirely, with wildly varying code quality.</p><p><strong>Architecture Drift:</strong> AI-generated code doesn’t follow company standards, leading to inconsistent patterns across the codebase.</p><p><strong>Knowledge Silos:</strong> When someone figures out how to get great results, that knowledge stays trapped in their head instead of spreading across teams.</p><p>Let’s be clear about something though: You are not going to lose your job to AI. You’re using AI to do the exhaustive parts of the work for you.</p><p>The good news is that these problems are all solvable. AI code assistants need structure to deliver consistent value.</p><h3>The Human Test: Can Someone Else Do This Task?</h3><p>Here’s a simple test to check if your prompt has enough context:</p><p>Think about the last time you picked up a ticket with incomplete requirements<strong>.</strong> The description says “Add user validation” but doesn’t specify what fields to validate, what error messages to show, or how it should integrate with the existing system.</p><p>Could you complete that task without asking clarifying questions? Of course not.</p><p>Now imagine using that same vague description as your AI prompt: “Add user validation to this function.”</p><p>If a human developer couldn’t complete the task with those instructions, neither can the AI.</p><p><strong>AI cannot read your mind, just as humans cannot.</strong></p><p>The better your instructions, the better the output. This applies whether you’re delegating to a junior developer, a contractor, or an AI assistant.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FW0GVioYftFYARbCYM7PMA.png" /></figure><h3>Example: Does This Pass the Human Test?</h3><p><strong>❌ Fails the human test:</strong></p><pre>Add user validation</pre><p>Questions a human would ask:</p><ul><li>Which fields need validating?</li><li>What are the validation rules for each field?</li><li>What format should error messages be in?</li><li>Where should validation happen (frontend, backend, both)?</li><li>How should this integrate with our existing validation?</li><li>What happens when validation fails?</li><li>Do we need to log validation failures?</li></ul><p><strong>✓ Passes the human test:</strong></p><pre>Add validation to the user registration endpoint:<br><br>Fields to validate:<br>- Email: valid format, check domain exists, max 255 chars<br>- Password: min 12 chars, requires uppercase, lowercase, number, symbol<br>- Phone: optional, UK format if provided (E.164)<br>- Date of birth: required, must be 18+<br><br>Context:<br>- Python 3.11 with FastAPI<br>- Use Pydantic for validation (like our login endpoint)<br>- Return errors in GOV.UK Design System format<br>- Log validation failures for analytics (no PII)<br><br>Integration:<br>- Follows the pattern from our login endpoint (see below)<br>- Integrates with our existing error handling middleware<br><br>[paste example of existing login validation]</pre><h3>What You Need to Provide</h3><p>Think about what a human needs:</p><ul><li><strong>The goal:</strong> What are they building and why?</li><li><strong>The environment:</strong> What tools, frameworks, databases are available?</li><li><strong>The constraints:</strong> Performance, security, scalability requirements</li><li><strong>The examples:</strong> How have we solved similar problems before?</li><li><strong>The standards:</strong> Coding style, patterns, naming conventions</li><li><strong>The integration points:</strong> What does this connect to?</li></ul><p>If you give this information to a human, they can complete the task. If you give it to AI, it can too.</p><h3>Why This Matters for Teams</h3><p>When everyone applies “the human test” before prompting AI:</p><ul><li>Code quality becomes consistent</li><li>AI-generated code fits existing patterns</li><li>Less time wasted on revisions</li><li>Architecture standards are maintained</li><li>Knowledge isn’t siloed (context is explicit in prompts)</li></ul><p><strong>Remember:</strong> AI is powerful, but it’s not psychic. Treat it like a very capable colleague who’s just joined your team, give them all the context they need to succeed.</p><h3>Five Core Techniques</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_Ours91vA2if4mcARTT5Yg.png" /></figure><p>Once you understand the human test, these five techniques will transform your results:</p><h3>1. Chain of Thought Reasoning</h3><p>Get the AI to show its working:</p><pre>Walk me through your thought process step by step as you <br>design this solution...</pre><h3>2. Few-Shot Prompting</h3><p>Teach by example:</p><pre>Here&#39;s how we handle similar cases in our codebase:<br>[paste example]<br><br>Now write this new function following the same patterns.</pre><h3>3. Reverse Prompting</h3><p>Make the AI ask YOU questions first:</p><pre>Before you get started, ask me for any information you <br>need to do a good job.</pre><h3>4. Role Assignment</h3><p>Change expertise level and perspective:</p><pre>Act as a senior Python developer...<br><br>Act as a security expert reviewing this code...</pre><h3>5. Emphasis/Emotional Manipulation</h3><p>Add context about importance to improve output quality:</p><pre>This is critical for production code that handles sensitive user data.<br><br>Think carefully about edge cases - this function processes financial transactions.<br><br>This is important for my team&#39;s code review - please be thorough.</pre><p><strong>Why this works:</strong> Just as you’d give a colleague more context about why something matters, AI responds to framing that indicates the stakes and required quality level.</p><h3>Combine Them</h3><p>The most effective prompts use multiple techniques:</p><pre>Help me write a user authentication function.<br><br>This is critical for production - we handle 10,000+ logins daily. (Emphasis)<br><br>Before you start, ask me questions about security requirements <br>and error handling. (Reverse Prompting)<br><br>Here&#39;s an example from our codebase: [paste example] (Few-Shot)<br><br>Walk me through your design approach step by step. (Chain of Thought)<br><br>Act as a senior backend developer with security expertise. (Role)</pre><h3>Practical Applications</h3><h3>Writing Functions: The Iterative Approach</h3><p>Don’t try to get perfect code in one prompt. Build it up systematically, this is where iterative improvement excels.</p><p><strong>The power of iteration:</strong> Code never comes without bugs, whether it’s AI-generated or human-written. Building functionality in layers helps you understand each piece before moving forward.</p><p><strong>Round 1: Get the basics working</strong></p><pre>Help me write an async function to update user profiles.<br><br>Context:<br>- Python 3.11 with FastAPI<br>- PostgreSQL with SQLAlchemy<br>- Async/await patterns throughout<br><br>Before you start, ask me about validation and error handling requirements.</pre><p><strong>Round 2: Layer on validation</strong></p><pre>Now add Pydantic validation for:<br>- Email format<br>- Phone number (E.164 format)<br>- Required vs optional fields</pre><p><strong>Round 3: Security review</strong></p><pre>&quot;Act as a security expert. Review this function for:<br>- Input sanitisation<br>- SQL injection risks<br>- Data exposure in error messages&quot;</pre><p>Each iteration adds a layer of production readiness. You understand the code because you built it up gradually.</p><h3>Using EDIP for Learning New Concepts</h3><p>When I’m learning something completely new or encountering unfamiliar code, I use EDIP - a teaching framework that translates perfectly to learning with AI:</p><p><strong>Explain:</strong> Ask the AI to explain the concept</p><pre>Explain how to stream audio responses from an API in Angular.<br>What&#39;s the difference between returning a blob vs a ReadableStream?<br>When would I use each approach?</pre><p><strong>Demonstrate:</strong> Ask for a concrete example</p><pre>Show me a simple example of an Angular service method that streams audio.<br>Include:<br>- HTTP POST to API<br>- Handling the stream response<br>- Basic error handling</pre><p><strong>Imitate:</strong> Create something similar with guidance</p><pre>Now help me write a streaming method for our audio service.<br><br>Context:<br>[paste existing non-streaming method for reference]<br><br>Requirements:<br>- Stream audio from Azure Speech API<br>- Use fetch API (not HttpClient) for streaming support<br>- Include authentication token handling<br>- Follow our existing service patterns</pre><p><strong>Practice:</strong> Apply it independently with review</p><pre>Review this streaming method I wrote:<br>[paste my implementation]<br><br>Does it follow best practices?<br>How&#39;s the error handling?<br>Any potential issues with memory or performance?</pre><p><strong>Real example:</strong> When we needed to change our audio service from downloading complete files to streaming them for performance, I used EDIP. I went from not understanding streaming APIs in Angular to implementing a production-ready solution, learning concepts, seeing examples, building with guidance, then refining through review.</p><p>EDIP works because it mirrors how we naturally learn, understand the concept, see it in action, try it yourself, then refine through practice. Notice how EDIP naturally incorporates the prompting techniques: Reverse Prompting in the Explain phase (asking the AI to clarify concepts), Few-Shot in Demonstrate (requesting examples), Chain of Thought in Practice (asking for step-by-step review).</p><p>From explaining quadratic equations to teaching animal behaviour, I learned that breaking complex problems into smaller steps makes them manageable. Whether it’s a 14-year-old learning algebra or me learning Angular streaming APIs, the principle is the same.</p><p>AI excels at each of these steps when you structure your prompts around this framework and you build understanding incrementally rather than expecting perfection immediately.</p><h3>Refactoring: The Three-Step Approach</h3><p><strong>Step 1: Analyse (don’t touch code yet)</strong></p><pre>Act as a code reviewer. Analyse this function:<br>[paste code]<br><br>Identify code smells, complexity issues, and testability problems.<br>Don&#39;t refactor yet-just analyse.</pre><p><strong>Step 2: Plan</strong></p><pre>Based on your analysis, create a refactoring plan:<br>1. What patterns should we apply?<br>2. What&#39;s the order of changes?<br>3. How do we maintain backwards compatibility?</pre><p><strong>Step 3: Execute incrementally</strong></p><pre>Let&#39;s implement step 1 from your plan.<br>Show me the refactored code and explain what changed.</pre><p>Test after each step. Never refactor everything at once.</p><h3>Debugging: Provide Complete Context</h3><p>When debugging, give the AI everything a human colleague would need:</p><pre>I&#39;m getting this error in the browser console:<br>[error message]<br><br>In this Angular component:<br>[paste relevant component code]<br>Expected behaviour: Audio plays when user clicks play button<br>Actual behaviour: Button shows loading state but no audio plays<br><br>Environment:<br>- Angular 19, TypeScript<br>- Streaming audio from Azure Speech API<br>- This worked in development, fails in staging<br><br>Recent changes:<br>- Changed from downloading blob to streaming ReadableStream<br>- Updated authentication token handling<br><br>What could be causing the streaming to fail?</pre><p><strong>What makes this effective:</strong></p><ul><li>Specific error message (not just “it doesn’t work”)</li><li>Relevant code (not entire component, just what matters)</li><li>Expected vs actual behaviour (clear comparison)</li><li>Environment context (Angular version, what API you’re using)</li><li>Timeline (worked before, broke after specific changes)</li><li>What changed recently (narrows down the issue)</li></ul><p>The AI will systematically explore possibilities based on your context, maybe token expiry, CORS issues, stream handling differences between environments, or API configuration.</p><h3>Beyond Code Generation</h3><p>AI assistants can serve multiple roles:</p><h3>As a Coach</h3><pre>I&#39;m new to async/await in Python.<br>Explain:<br>1. What problem does it solve?<br>2. When should I use it vs regular functions?<br>3. Show me a simple example<br>4. What are common mistakes?</pre><h3>As a Design Consultant</h3><pre>I need to implement a notification system for email, SMS, and push.<br><br>Give me 3 different architectural approaches with pros and cons.<br>Consider scalability and maintainability.</pre><h3>For Fast-Track Onboarding</h3><pre>I&#39;m new to this codebase. Here&#39;s the main application file:<br>[paste code]<br><br>Help me understand:<br>1. What does this do at a high level?<br>2. What are the main components?<br>3. What would be a good first contribution?</pre><h3>When AI Gets It Wrong (And What to Do About It)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*h5_TuWRGvujNlscuiRRILQ.png" /></figure><p>AI-generated code isn’t automatically good code. Here are the pitfalls I’ve encountered:</p><h4>Security Vulnerabilities</h4><p>Real example: Copilot suggested using regex for input validation. The code worked perfectly in testing, but when we ran it through OWASP and SonarQube (our standard security checks), it flagged a ReDoS (Regular Expression Denial of Service) vulnerability.</p><p>The lesson: AI doesn’t know your security standards. Always run generated code through your organisation’s security checks: SonarCloud, OWASP Dependency-Check, whatever your process requires. Treat AI-generated code the same way you’d treat code from any new team member. Review it, test it, scan it.</p><h4>The Loop of Despair</h4><p>You know this scenario: AI suggests a fix. It doesn’t work. You ask for another fix. That makes it worse. You keep iterating, and suddenly you’re 20 minutes into solving what should have been a 2-minute problem.</p><p>When this happens, stop. Step away from the AI. Look at the actual problem with fresh eyes. Often, you’ll spot a simple solution you missed because you were too focused on making the AI’s approach work.</p><p>Warning signs you’re in the loop:<br>- The AI’s suggestions are getting increasingly complex<br>- You’re not understanding the changes anymore<br>- The code is drifting further from your codebase patterns<br>- You’ve been iterating for more than 3 or 4 rounds</p><h4>When to Skip AI Entirely</h4><p>Some tasks are faster without AI:<br>- Quick variable renames (your IDE does this better)<br>- Simple logic you already understand<br>- Hotfixes where you need to understand every character<br>- Anything touching authentication or payment processing (do this yourself, review carefully)</p><p>Remember: AI is a tool, not a requirement. Sometimes the simple approach is better than the powered one.</p><h3>Using Instruction Files</h3><p><strong>Real example: Angular project consistency</strong></p><p>On the government project, I created an instructions.md file specifically to keep GitHub Copilot generating consistent Angular code:</p><p>markdown</p><pre># GitHub Copilot Instructions<br><br>## Angular Standards<br>- Use Angular 19 control flow (@if, @for) NOT ngIf/ngFor<br>- Standalone components only (no NgModules)<br>- Use signals for state management<br>- Follow Angular style guide naming conventions<br>## Project Patterns<br>- Services use dependency injection<br>- API calls go through Azure service wrapper (see auth.service.ts)<br>- Error handling uses our custom error interceptor<br>- All user-facing text goes through translation service<br>## Testing<br>- Unit tests with Jest<br>- Follow our Jest test patterns (see example-component.spec.ts)<br>- Accessibility testing with axe-core (A11y)<br>- Test descriptions should clearly state what&#39;s being tested</pre><p><strong>The difference this made:</strong> Before the instructions file, Copilot kept suggesting ngIf (the old syntax). After adding the instruction to use @if, every suggestion was correct. It saved hours of manual corrections.</p><p><strong>Go deeper with quality rules:</strong> Don’t just specify coding patterns. Include your SonarCloud rules, linting configurations, and quality gates directly in instruction files:</p><pre>## Code Quality Standards <br>- Maximum cyclomatic complexity: 10 <br>- No console.log in production code <br>- All functions must have JSDoc comments for public APIs <br>- No magic numbers <br>- use named constants <br>- Follow our SonarCloud ruleset (link to wiki)</pre><p>When AI knows your specific quality standards upfront, it generates code that passes your checks the first time rather than requiring multiple revision cycles.</p><p><strong>For your team:</strong> Whether using GitHub Copilot, Claude Code, or Amazon Q, instruction files ensure everyone gets consistent suggestions. New team members automatically follow your standards.</p><p><strong>Framework-specific guides:</strong> Many modern frameworks now provide AI-specific guidance. Angular has published official <a href="https://angular.dev/ai/develop-with-ai">AI development guidelines</a> that cover common patterns, gotchas, and best practices. Include these framework guides in your instruction files to help AI understand context-specific conventions.</p><h3>Testing and Documentation</h3><h3>Testing Approach</h3><p><strong>Real example: Writing consistent Playwright tests</strong></p><p>On the government project, I used GitHub Copilot to write Playwright tests for our Angular application:</p><pre>Write a Playwright test for the letter preview feature.<br><br>Use this template as your guide:<br>[paste existing test showing page object pattern]<br><br>Test requirements:<br>- User can preview personalised letter<br>- Correct child name appears in preview<br>- Audio playback button is visible<br>- Download button works<br>- Follow our page object pattern exactly<br><br>Context: TypeScript, Playwright</pre><p><strong>What I learned:</strong> Giving Copilot a template to follow was game-changing. Every test followed the same pattern, same structure, same assertions, same error handling. This consistency made the test suite maintainable.</p><p><strong>Key insight from teaching:</strong> When I was a teacher, I always gave students a worked example before asking them to complete similar problems independently. AI works the same way, show it what “good” looks like, then ask it to replicate the pattern.</p><h3>Documentation Best Practices</h3><p>The first rule: Your code explains WHAT, comments explain WHY.</p><p><strong>From my experience:</strong> Code never comes without bugs, whether it’s AI-generated or human-written. Good documentation is your future self’s (or your colleague’s) best friend.</p><pre>Review this Azure service integration and add comments explaining:<br>- WHY we&#39;re using this specific API endpoint<br>- WHY we&#39;re streaming instead of downloading<br>- WHY we have this error handling<br>- Any gotchas or non-obvious behaviour<br><br>Don&#39;t comment WHAT the code does - that should be clear from the code itself.</pre><p><strong>Good vs bad comments:</strong></p><pre>// ❌ Bad: States the obvious<br>const audioUrl = response.data.url; // Get the audio URL<br><br>// ✅ Good: Explains why<br>const audioUrl = response.data.url; // Stream URL expires in 5 mins - use immediately<br><br>// ❌ Bad: Explains what (code already does this)<br>// Loop through letters and display them<br>letters.forEach(letter =&gt; displayLetter(letter));<br><br>// ✅ Good: Explains why/how it handles edge cases<br>// Process letters in batches to avoid overwhelming the translation API<br>// If any batch fails, we continue with the next (failures logged for retry)<br>for (const batch of chunk(letters, 10)) {<br>  try {<br>    await processLetterBatch(batch);<br>  } catch (error) {<br>    logger.error(&#39;Batch failed&#39;, { batch, error });<br>    continue;<br>  }<br>}</pre><p><strong>Pro tip:</strong> Don’t just copy-paste AI-generated code and move on. Review it, test it, and ensure it meets your team’s standards. Use AI to do the exhaustive work, but keep your expertise and judgment in the loop.</p><h3>Working with AI Agents</h3><p><strong>Chat-based assistants</strong> (Claude, ChatGPT): You paste code, AI suggests, you apply manually.</p><p><strong>Agentic systems</strong> (GitHub Copilot, Claude Code, Amazon Q): AI can read/write multiple files directly.</p><h3>When to Use Each</h3><p><strong>Use chat for:</strong></p><ul><li>Learning and exploration</li><li>Complex business logic</li><li>Security-critical code</li><li>When you need to understand every change</li></ul><p><strong>Use agents for:</strong></p><ul><li>Renaming across codebase</li><li>Formatting fixes</li><li>Repetitive refactoring</li><li>Adding logging throughout</li></ul><h4>Never Blindly Accept</h4><p><strong>The rule:</strong> If you don’t understand code well enough to maintain it, don’t merge it.</p><h3>Tools Referenced</h3><p>Throughout this article, I reference specific AI assistants:</p><p><a href="https://github.com/features/copilot">GitHub Copilot</a>: My daily driver for the past year. Works directly in your IDE with autocomplete, chat, and agent modes.</p><p><a href="https://claude.com/product/claude-code">Claude Code</a>: Command-line agentic tool for multi-file operations.</p><p><a href="https://aws.amazon.com/q/">Amazon Q</a>: AWS’s AI assistant, particularly good for AWS-related tasks.</p><p>Quality Gates: <a href="https://www.sonarsource.com/products/sonarqube/cloud/">SonarCloud</a> for code quality checks, <a href="https://owasp.org/www-project-dependency-check/">OWASP Dependency-Check</a> for CVE vulnerabilities. AI-generated code goes through the same checks as human-written code.</p><p>The techniques in this article work with any AI assistant. They’re about effective prompting, not specific tools.</p><h3>Key Principles</h3><p><strong>1. Context is everything</strong></p><ul><li>Apply the human test to every prompt</li><li>Include tech stack, constraints, patterns</li><li>Show examples from your codebase</li></ul><p><strong>2. Iterate, don’t expect perfection</strong></p><ul><li>Build functionality in layers</li><li>Switch roles for different perspectives</li><li>Understand before moving forward</li></ul><p><strong>3. Use the right technique</strong></p><ul><li>Simple tasks: Role + Context</li><li>New features: Reverse Prompting + Chain of Thought</li><li>Consistency: Few-Shot + Examples</li><li>Critical code: Combine all techniques</li></ul><p><strong>4. Never blindly accept</strong></p><ul><li>Understand every change</li><li>Test everything</li><li>Keep humans in the loop</li><li>You’re the architect, AI is the assistant</li></ul><h3>Solving the Adoption Challenges</h3><p>Remember those problems from the beginning?</p><p><strong>Inconsistent results?</strong> Fixed by the human test and standard prompting patterns.</p><p><strong>No shared standards?</strong> Create a team prompting guide. Share examples that work. Use instruction files.</p><p><strong>Architecture drift?</strong> Few-shot prompting with your existing patterns keeps AI output consistent.</p><p><strong>Knowledge silos?</strong> Document effective prompts. When someone discovers a great technique, share it.</p><h3>Your Next Steps</h3><ol><li><strong>Apply the human test</strong> to your next AI prompt</li><li><strong>Try one technique</strong> from this article</li><li><strong>Create an instruction file</strong> for your project</li><li><strong>Share what works</strong> with your team</li></ol><p>AI coding assistants don’t replace skill, they amplify it. The better you understand software development, the better you can direct AI to help you.</p><p>After 20 years of teaching and a year of using AI assistants daily, I’ve learned this: the best teachers break down complex problems, provide clear examples, and build understanding step by step. The best AI users do exactly the same thing.</p><p>You won’t lose your job to AI. But you will need to learn how to communicate what you want clearly and verify what you get back. Start with one technique from this article. Apply the human test. Create an instruction file. Share what works.</p><p>The skill isn’t writing every line anymore. It’s knowing what to build and how to direct the building of it.</p><h3>About the Author:</h3><p>Alana Barrett-Frew is a Python Developer at <a href="https://www.version1.com/">Version 1</a>.</p><p>I came to software development after 20 years teaching maths, geography, PE, and animal care. That background shapes how I approach AI assistants. The techniques that worked in the classroom (breaking down problems, showing examples, building understanding incrementally) translate directly to getting good results from AI.</p><p>Follow me as I navigate and blog my journey through tech.</p><ul><li><a href="https://www.linkedin.com/in/alanabarrettfrew/">LinkedIn</a></li><li><a href="https://www.alanabarrettfrew.com/">Website</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0b89d01b2869" width="1" height="1" alt=""><hr><p><a href="https://medium.com/version-1/how-to-get-the-best-out-of-your-ai-code-assistant-0b89d01b2869">How to Get the Best Out of Your AI Code Assistant</a> was originally published in <a href="https://medium.com/version-1">Version 1</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>