Good morning, AI enthusiasts!
There’s a big difference between getting an AI agent to write code and getting it to produce code you can actually ship. This week, I’m sharing the workflows we use at Towards AI to close that gap, from context and debugging to testing and review.
I also have a simple rule for testing stochastic LLM systems that catches failures a single successful run can hide. And if you use Claude Code or Codex regularly, I’m opening up my own AI engineering setup in a live workshop with Packt, including how I work across agents, manage usage limits, and keep skills and knowledge synced.
Plus, this week’s reads will help you:
Let’s dive in!
This week, in What’s AI, I am sharing what the Towards AI engineering team uses to ship reliable code with AI agents, including three AI coding workflows, context rules, debugging habits, tests, and review guardrails. There is still a huge gap between the people who ship working products with agents and the people who ship working demos. This article shares everything you need to close that gap. By the end, you will have the best practices for your own repo, whether you are a developer learning to direct agents or a beginner upgrading from random vibe coding to something that ships. Read the full article here, or, if you prefer, watch the walkthrough on YouTube.
A student in our 10-Hour LLM Fundamentals Video Course asked us a useful question: How many times should you run an important test before trusting the result?
For stochastic LLM tests, our practical baseline is five runs. Suppose a difficult test passes 90% of the time. If you run it once and it passes, you might conclude that everything is working. Run the same test five times, though, and there is about a 41% chance you will see at least one failure.
For important tests, run the same case five times and record two things: Keep the prompt, model, temperature, and other randomness settings, as well as the source context, fixed. Otherwise, you are changing the test while trying to measure its consistency.
Five runs is not a statistical guarantee. It is a simple way to catch intermittent failures that a single successful run can easily hide.
— Louis-François Bouchard, Towards AI Co-founder & Head of Community
In other exciting news, I’m doing a 90-minute live workshop with Packt on how I’ve structured my own AI engineering setup around coding agents like Claude Code and Codex.
If you’re already using agents in your workflow, this should be especially useful. You’ll see how I: Who it’s for: AI engineers and developers already using coding agents who want a more structured system around them.
Jose_sonder has built SkillNet, an open-source adaptive learning system. Users can share a topic or existing material, and it builds a structured course that presents the same knowledge differently for each learner. It can run as a shared space for an organization or class, or as an individual learning workspace. In a dynamic course, the shared knowledge and objectives remain stable, while the explanation, activities, support, and interface adapt based on the learner’s declared preferences, role, level, and progress. Check it out on GitHub and support a fellow community member. If you have any questions or feedback, share them in the thread.
Most of you are still on free or basic plans, which makes me wonder how coding agents actually fit into your work today. Are they already handling a meaningful share of your coding and automation, or are you still bringing them in for specific tasks where they are particularly useful?
I’m also curious about the people at either end. If you’re paying for 5x or more, what makes the extra capacity worthwhile? Is it simply that you use agents much more often, or is staying within a familiar Claude Code/Codex workflow valuable enough that you would rather pay than move work elsewhere?
And the 8% running locally might be the group I’m most curious about: what are you running, on what hardware, and which parts of your workflow have you been able to move local?
There are probably some very different AI engineering setups hiding behind these percentages. Share yours in the thread, especially what you use, what you pay for, and what still runs locally.
Meme shared by bin4ry_d3struct0r
How The Fast Fourier Transform Actually Works by Kamrun Nahar
If you have used a Fast Fourier Transform (FFT) without really understanding what happens underneath, this article builds the intuition from the ground up. It starts with sine waves, implements the Discrete Fourier Transform in Python, and checks the result against NumPy before explaining how the FFT makes the same computation practical at scale. You’ll also see how sampling rate, aliasing, spectral leakage, and windowing affect the frequencies you recover from real signals, then apply the ideas to spectrograms, compression, MRI, and audio forensics.
Inference performance depends on more than GPU compute. This article shows how storage can reduce the amount of work your GPUs repeat. It explains Microsoft Foundry’s three levels of prompt caching, including Azure Context Cache for sharing cached prefixes across nodes, then shows how NIXL and LMCache move KV caches beyond GPU memory. You’ll also learn how Run:ai Model Streamer and AKS caching reduce model- time, giving you a practical map of where storage can improve latency, GPU utilization, and inference cost.
Long context can exhaust GPU memory even when the model itself fits comfortably. This article shows you exactly why by calculating KV-cache memory from a model’s architecture, sequence length, precision, and batch size. Using gpt-oss-120b on two H100s shows that capacity drops from 504 concurrent conversations at 4K tokens to just 15 at 128K tokens. It then works through six ways to recover capacity, including grouped-query attention, sliding windows, prefix caching, paging, and FP8 quantization.
Text watermarking can work without inserting hidden characters or maintaining a list of special words. This article explains how watermarking can modify token probabilities during generation, including the green-list approach and the distortion-free method used in Google’s SynthID-Text. It then derives how a simple z-score can detect the resulting statistical pattern and tests both methods inside a real inference engine. You’ll also see where the approach breaks down: changes in paraphrasing, translation, and tokenization can weaken or remove the signal.
- Beyond RAG: Implementing Agentic Memory Architectures for Long-Horizon AI Systems by Sourav Mukherjee
RAG can retrieve what an agent needs in the moment, but it does not automatically help the agent learn from past events. This article builds a memory architecture that separates episodic memory (what happened), semantic memory (what the agent learned), and procedural memory (how it should behave). It then adds consolidation to turn past interactions into reusable knowledge and reflection to promote successful lessons into future behavior. Comparisons with Mem0, Letta, and LangGraph help you see how these ideas translate into existing memory frameworks and what you need beyond retrieval for agents that operate across many sessions.
If you are interested in publishing with Towards AI, check our guidelines and sign up. We will publish your work to our network if it meets our editorial policies and standards. LAI #140: Our AI Coding Playbook was originally published in Towards AI on Medium, where people are continuing the conversation by highlighting and responding to this story.