<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Gaetan Juvin on Medium]]></title>
        <description><![CDATA[Stories by Gaetan Juvin on Medium]]></description>
        <link>https://medium.com/@gtnjuvin?source=rss-66b78b596732------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*_gMDwPVyadMnKaKKlR6APQ.jpeg</url>
            <title>Stories by Gaetan Juvin on Medium</title>
            <link>https://medium.com/@gtnjuvin?source=rss-66b78b596732------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 18:31:05 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@gtnjuvin/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Cognition Is Almost Free. Being Wrong Isn’t.]]></title>
            <link>https://medium.com/@gtnjuvin/cognition-is-almost-free-being-wrong-isnt-8ddcc655d01b?source=rss-66b78b596732------2</link>
            <guid isPermaLink="false">https://medium.com/p/8ddcc655d01b</guid>
            <dc:creator><![CDATA[Gaetan Juvin]]></dc:creator>
            <pubDate>Sun, 08 Nov 2026 02:11:32 GMT</pubDate>
            <atom:updated>2026-11-08T02:11:32.403Z</atom:updated>
            <content:encoded><![CDATA[<p><em>The next AI moat isn’t the model. It’s the guarantee.</em></p><p>For a growing class of routine tasks, what used to take an associate an afternoon can now take an agent a minute. The marginal cost of competent work is falling quickly.</p><p>The cost of producing work or completing tasks has fallen in many areas, but the work produced, as we all know, is not necessarily top quality or correct. So what has happened to the price of getting something right, of delivering quality work?</p><p>Customers still pay real money for a company formed correctly, a contract that holds up, a filing that doesn’t bounce. A cheap draft can still be an expensive mistake. Somewhere between cheaper production and costly failure, there is room for a valuable business. I think most of us are looking for it in the wrong place.</p><h3>The satisfying story, judgment is our moat</h3><p>Ask a room of senior leaders what stays valuable when AI does more of the thinking, and you will hear one word: <strong>judgment</strong>.</p><p>I am no longer sure this is a sufficient answer.</p><p>The problem is that the line of what models are capable of doing well keeps moving. Creativity was supposed to be safe. So was work that required understanding context. As models improve, “judgment” risks becoming the name for whatever remains just out of reach. It is a comfortable story, especially for those of us with judgment to sell.</p><p>Judgment still matters, but its scarcity is a harder claim to defend.</p><p>I want a claim that depends less on a lasting capability gap: what do customers still need when competent work becomes abundant?</p><h3>Context and accountability</h3><p>Two things matter here: context and accountability. Context is knowing the specific situation: what this client actually wants, why the last attempt failed, which constraint is written nowhere. Accountability is being on the hook when it goes wrong.</p><p>Context does not stay exclusively human just because it starts out tacit. Once agents sit inside the email, the tickets, the calls and the CRM, a growing share of it becomes accessible to machines.</p><p>But accessible to an agent does not mean available to every competitor. Private customer history is still private. Current information still has to be distinguished from stale information, and conflicting accounts still have to be resolved. Better agents can make access to trustworthy context more valuable.</p><p>The human monopoly on using context is eroding. The context itself has not necessarily become a commodity.</p><p>Accountability raises a different question: once the work leaves the system, who owes the customer what if it goes wrong?</p><h3>Accountability lives on balance sheets</h3><p>This is where my own argument turned on me. I started out thinking accountability was the last refuge of the human professional; it isn’t.</p><p>At a commercial level, accountability means an enforceable obligation backed by resources. Individuals can carry accountable items or requirements through their practice, insurance and reputation. Firms can do the same through process control, failure data, KPIs, and financial capacity at scale. The more a company is worth, the more that hangs in the balance when it comes to obligations and accountable items or requirements, the more the promise of delivering on said accountability has weight.</p><p>But the promise of acceptable, high quality work, or delivering “correct” work needs a definition (hence the lengthy contracting process of MNEs), but this is easier said than done.</p><p>Suppose a filing service causes a missed deadline. Regenerating the document does nothing about the penalty. A promise to cover that penalty, up to a stated limit, transfers a specific risk to the provider; a promise to correct the document transfers much less.</p><p>A refund, free rework and compensation for a customer’s loss are different products. The boundary is part of what the customer is buying.</p><p>That is the shift I am interested in: selling a defined outcome with a meaningful remedy when the provider fails to deliver it.</p><p>Context and accountability need each other. Context helps you understand the situation well enough to define and price the promise. Accountability gives you a reason to care about what happens after the output ships.</p><h3>Isn’t protecting the delivery of a defined outcome just insurance?</h3><p>The obvious objection: this sounds like risk coverage bundled into the price. Warranties are ancient, so what’s new?</p><p>The guarantee itself isn’t new. AI can change the range of services in which it is economical to offer one. The potential advantage comes from controlling the process that creates the loss.</p><p>Insurance already includes active loss prevention. <a href="https://www.fm.com/solutions/risk-management">1</a> A producer’s potential advantage is the ability to observe and change the workflow directly: catch a missing field before submission, check a requirement before it becomes a rejection, stop a faulty release before it reaches the next customer.</p><p>That advantage has to be earned. Claims and verified outcomes need to produce changes that reduce future losses. Owning the process does not automatically mean understanding it.</p><p>A useful precedent is title insurance. Before issuing coverage, title companies search for defects that can be resolved or excluded. Verification and a financial promise sit inside the same product.</p><p>It also shows the trap. A <a href="https://www.gao.gov/assets/gao-07-401.pdf">2007 GAO review found that claims</a> accounted for a small share of premiums, while a much larger share went to agents for searches, examinations and commissions. It questioned whether prices reflected underlying costs. A low claims bill does not tell you how much of the premium bought prevention, distribution or market power. <a href="https://www.gao.gov/assets/a259275.html">3</a></p><p>A guarantee economy can become a toll-booth economy, where the guarantee is a gate you must pass through rather than a promise you are glad to have.</p><h3>Where the margin comes from</h3><p>Taking responsibility creates a cost. Being better at preventing the losses you have accepted can create an advantage.</p><p>The margin comes from delivering a protected outcome at a lower total cost than the alternatives, while charging enough to survive the failures that remain. Cheap generation helps, but so do better prevention, earlier detection ,and faster intervention. Verification, claims handling, and the cost of capital still count.</p><p>The producer does not have to finance every loss itself. An outside insurer may supply capital more efficiently while the producer supplies better controls and operational evidence. Those advantages can coexist.</p><p>Nor does accountability guarantee a lasting premium, because competitors can copy the promise. If the same models and methods make everyone equally reliable, competition can push down the price of the guaranteed outcome too.</p><p>The defensible asset is thus the ability to keep the promise at a cost others struggle to match.</p><h3>Who is willing to be wrong for you?</h3><p>As competent cognitive work gets cheaper, a credible promise about the result becomes a more interesting place to compete.</p><p>The next part of the story is about who is willing to be wrong on your behalf, what they agree to pay for, and whether they can afford it. That takes balance sheets, reliable loss data and engineering discipline.</p><p>Accountability will still have a cost. The firms that understand and control that cost have a case for earning a premium.</p><p>Less exciting than “judgment is the new moat”, but I suspect it is closer to where the money will actually go.</p><p>I may be wrong about this. Conveniently, saying so costs me nothing.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8ddcc655d01b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How Agentic Builders Bend Brooks’s Law]]></title>
            <link>https://medium.com/@gtnjuvin/how-agentic-builders-bend-brookss-law-5468d994e693?source=rss-66b78b596732------2</link>
            <guid isPermaLink="false">https://medium.com/p/5468d994e693</guid>
            <dc:creator><![CDATA[Gaetan Juvin]]></dc:creator>
            <pubDate>Sun, 10 May 2026 15:36:00 GMT</pubDate>
            <atom:updated>2026-05-10T15:36:00.774Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PCWDasqACLWprFfdYC6yPA.png" /><figcaption><em>From human coordination overhead to agentic orchestration.</em></figcaption></figure><p>In 1975, Frederick Brooks published <em>The Mythical Man-Month</em> and made one observation that has outlived almost every technology it described: <strong>adding people to a late software project makes it later.</strong></p><p>The book talks about IBM mainframes and assembly programmers, but the law has held for fifty years across every language, framework, and methodology that came after. It held because the mechanism it described had little to do with the technology underneath. It described how humans coordinate.</p><p>Brooks’s argument rests on three things. Communication overhead between people grows as n(n-1)/2. New hires consume the time of existing engineers before they contribute anything back. And software work cannot be cleanly partitioned, because most meaningful tasks depend on a shared mental model.</p><p>Take those together and you get the law: more people, more coordination cost, slower throughput.</p><p>But that model assumed something specific. It assumed that the way to scale a software project was to add humans, and that the only way another human could contribute was by absorbing context from someone who already had it.</p><p>In that world, the bottleneck is not capacity. The bottleneck is shared understanding.</p><p>You cannot copy a mental model. You can only transfer it through conversation, documentation, code review, architecture reviews, planning meetings, and time. All of those are expensive. All of them scale poorly. And all of them are why Brooks’s Law has been the most quoted observation in software management for half a century.</p><p>What is changing now is not the law. It is the assumption underneath it.</p><p>A builder working with capable agents is not scaling in the same way. They are not adding another human node to the communication graph. They are adding execution capacity without requiring the same kind of human mental model transfer.</p><p>By builder, I do not mean someone who can merely write prompts. I mean someone with enough product judgment, technical taste, and system context to hold the intent of the work. Someone who can decide what should exist, recognize whether the output is good, and integrate it into a coherent system. That distinction matters.</p><p><strong>Agents reduce the skill-access problem. They do not remove the accountability problem.</strong></p><p>For most of software’s history, building required specialists. Front end, back end, infrastructure, security, data, machine learning, mobile, observability. Each layer had its own stack, conventions, failure modes, and tribal knowledge.</p><p>A founder who could build the API could not necessarily ship the iOS app. A backend engineer who knew Postgres deeply did not always know Kubernetes. A product engineer who could move quickly in the UI might not understand auth, data pipelines, or deployment constraints.</p><p>Coordination cost existed not because humans are inefficient, but because no single human could hold the full execution surface of a modern product.</p><p>The org chart was a workaround for the fact that one mind could not carry the whole system. Agents change that equation. Not perfectly. Not for every domain. Not without risk. But enough to change the unit of production.</p><p>The unit is no longer always a team.<br>Increasingly, the unit is a builder with judgment and an agent surface that translates that judgment into execution across layers the builder does not personally specialize in. That is a different model of scale. You do not assemble a team to compensate for every skill gap. You assemble a runtime that compensates for a throughput gap.</p><p>Those are not the same problem, and they do not have the same solution.</p><p>This is where Brooks’s Law starts to bend. The n(n-1)/2 communication graph does not apply in the same way when the builder is not adding another human node. The cost does not collapse to zero, but it collapses into a different shape: prompting, reviewing, verifying, correcting, and integrating.</p><p>Communication with yourself is still faster than delegation to another person. It always was. The reason we delegated was capacity, not preference.</p><p>Once a builder can issue work and absorb output without leaving their own context, the industrial logic of team scaling becomes less automatic. You do not need a meeting to align the agent. You do not need two months of onboarding before it contributes. You do not need to transfer political context, career incentives, or organizational history before work begins.</p><p>But you do need judgment. You need to know what good looks like. You need to see when the code is locally correct but globally wrong. You need to detect when an agent has solved the stated task while violating the intent. You need to preserve coherence across outputs that were generated quickly, separately, and often without full awareness of each other.</p><p>That is the new bottleneck. Brooks’s Law does not disappear. It moves.</p><p>In the industrial model, coordination was distributed across managers, product managers, tech leads, architects, rituals, and planning systems. Their job was to keep human mental models aligned across a widening surface area.</p><p>In the agentic model, coordination compresses back into the builder.</p><p><strong>The builder becomes the architect, reviewer, integrator, and source of conceptual integrity at once</strong>. That is a smaller coordination surface, but a denser one.</p><p>Less Brooks’s Law on the horizontal axis. More pressure on the vertical one.</p><p>This connects directly to the part of Brooks that most people forget. He did not only describe a coordination tax. He also argued that conceptual integrity is the most important property of a system, and that integrity comes from one mind, or from a small group sharing one mind.</p><p>Large teams often produce inconsistent systems because no single person truly holds the design. The product reflects the communication structure that built it. That is Conway’s Law. Fragmented teams produce fragmented systems. Agentic builders flip the economics of that problem.</p><p>The single-mind condition that Brooks believed produced the best systems, and that most organizations could not afford to preserve past a certain scale, becomes cheaper to maintain. A builder can hold the conceptual model while agents expand the execution surface around them.</p><p>That is the real shift. Not “AI writes code faster.”</p><p>The deeper change is that conceptual integrity no longer has to be sacrificed as quickly in order to scale execution.</p><p>But there are boundaries. This does not mean every enterprise system can be rebuilt by one person with agents. Regulated systems, high-scale platforms, deeply coupled legacy environments, security-sensitive systems, and ambiguous product domains still need teams. Some systems require independent review, separation of duties, institutional memory, and domain expertise that cannot be compressed into a single builder.</p><p>The point is not that teams disappear. The point is that the default reason for adding people changes.</p><p>If the problem is judgment, accountability, domain ownership, or risk management, you still need humans. If the problem is execution capacity across a known intent, agents increasingly become the first scaling layer.</p><p>That distinction will reshape org design. If you still build teams the way IBM built OS/360 teams, you are paying the Brooks tax by default. The leaner configuration is not only cheaper. In many cases, it produces better systems, because conceptual integrity is preserved instead of diluted through coordination layers.</p><p>The org chart that fits this world is shorter, denser, and biased toward builders who can sustain context. The best people are not just specialists. They are high-judgment generalists who can orchestrate execution while protecting the shape of the system.</p><p>Everything that used to be a coordination layer has to justify itself.</p><p>Some of it becomes an agent runtime.<br>Some of it becomes verification infrastructure.<br>Some of it becomes product and architectural judgment.<br>And some of it disappears.</p><p>The mistake is to think agents remove coordination. They do not. They remove a specific kind of coordination: the human-to-human transfer of context required before work can begin.</p><p>The remaining coordination is tighter, faster, and more intense. The builder has to preserve intent, review output, detect drift, and integrate pieces into a coherent whole.</p><p>That is why the agentic model favors people with judgment, taste, and systems thinking, not just people who can produce more code.</p><p>Brooks’s Law does not end because AI makes software easy. It changes because the default way to scale software work changes.</p><p>For fifty years, adding capacity meant adding people. Adding people meant adding coordination. Adding coordination meant slowing down.</p><p>Agents create another path. One builder can now expand execution capacity without expanding the human communication graph in the same way. The bottleneck moves from onboarding and alignment to judgment, verification, and conceptual integrity.</p><p>Brooks’s Law is not dead. It is no longer governing the same system. The smallest viable team finally got larger.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5468d994e693" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From TODOs to Task Graphs: Progress in AI-Assisted Software Development]]></title>
            <link>https://medium.com/@gtnjuvin/from-todos-to-task-graphs-progress-in-ai-assisted-software-development-d4f8f0f9f114?source=rss-66b78b596732------2</link>
            <guid isPermaLink="false">https://medium.com/p/d4f8f0f9f114</guid>
            <dc:creator><![CDATA[Gaetan Juvin]]></dc:creator>
            <pubDate>Mon, 26 Jan 2026 05:33:04 GMT</pubDate>
            <atom:updated>2026-01-26T05:33:04.474Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hM_ENyp6JxxRQQl2wmMtww.png" /></figure><p>We live in a fantastic time. In the span of two weeks, three things happened that most developers missed.</p><p>Amp removed the concept of to-dos from their coding agent, arguing that with the latest models, explicit task tracking was no longer necessary. Anthropic replaced their in-memory Todos with persistent Tasks that write directly to the filesystem. And Steve Yegge’s Beads, a git-backed issue tracker built specifically for AI agents, crossed tens of thousands of users.</p><p>These aren’t competing philosophies. They’re converging on the same insight.</p><p>The model isn’t the bottleneck anymore. The scaffolding around it is.</p><h3>Act 1: The Old World</h3><p>The first generation of AI coding tools were assistants. Copilot suggested the next line. ChatGPT answered questions. Claude helped you think through architecture. The workflow was simple: prompt, output, review, repeat.</p><p>This works for small tasks. Greenfield projects. Isolated functions. Anything you can hold in your head and verify by inspection.</p><p>It breaks the moment you need sustained, multi-step work.</p><p>The problem isn’t intelligence. It’s memory. Every new context window starts fresh. The model has no awareness of prior decisions, no persistence of project context, no state beyond what fits in the current prompt. When the context fills up , or you close your laptop and come back tomorrow, the plan vanishes.</p><p>Nick Tune, author of <em>Architecture Modernization</em>, captured the frustration in a November 2025 post: “The Claude Code todo list doesn’t persist across sessions, so when the context window gets full and you want to start a new conversation with a clear context window, it’s gone.” His workaround — manually telling Claude to read a todo file, pick the next item, mark it complete, felt like regression. “My expectations of AI-assisted development are a little higher than that,” he wrote. “Do I sound like a diva?”</p><p>He wasn’t alone. Research from UC San Diego and Cornell published in January 2026 confirmed what practitioners already knew: experienced developers with three or more years of professional experience don’t “vibe code.” They maintain strict control over AI agents because they’ve learned, through pain, that the model forgets.</p><p>Here’s the tension: the model is capable of far more than we let it do. But the workflow doesn’t let it compound progress. Each session is an island. Each task is a one-shot. The model can think, but the system can’t remember.</p><h3>Act 2: RALPH</h3><p>Geoffrey Huntley looked at this problem and asked a different question. What if we stopped treating the LLM as a one-shot oracle?</p><p>The answer was RALPH, the Ralph Wiggum Loop. Named after the lovably persistent Simpsons character who keeps trying, unbothered by setbacks, blissfully unaware of obstacles that would stop others.</p><p>The technique is almost embarrassingly simple:</p><pre>while :; do<br>  cat PROMPT.md | claude-code --continue<br>done</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6EOQ7bC59IicZTr7dMb4Uw.png" /></figure><p>That’s it. An infinite loop that repeatedly feeds the same prompt to an AI coding agent. But here’s the key: progress doesn’t persist in the LLM’s context window. It lives in your files and git history.</p><p>“That’s the beauty of Ralph,” Huntley explained. “The technique is deterministically bad in an nondeterministic world.”</p><p>You define tasks in a markdown or JSON file with explicit pass/fail criteria. The loop grabs the first failing task, sends it to the LLM with context about the current state of the codebase, and lets it work. When the agent tries to exit, a stop-hook intercepts the attempt. If the agent hasn’t output &lt;promise&gt;COMPLETE&lt;/promise&gt;, the loop feeds the prompt back in. The agent sees its previous work—the modified files, the git commits, the test results, and picks up where it left off.</p><p>The model iterates. The filesystem remembers. Git becomes the memory layer.</p><h3>The Overnight Migration</h3><p>A developer on the Claude Code community forums shared a story that became legendary in RALPH circles.</p><p>He had a codebase with integration tests that took four minutes to run. The tests worked, but they were slow, hitting real databases, making actual network calls, the kind of tests that accumulate in legacy systems because nobody has time to fix them properly.</p><p>He wrote a RALPH prompt: convert each integration test to a unit test. Mock the external dependencies. Maintain the same assertions. Success criteria: all tests pass, coverage stays above 80%, no integration tests remain.</p><p>He started the loop before bed. Fifty max iterations. Let it run.</p><p>When he woke up, the loop had completed in 34 iterations. The test suite now ran in two seconds. Every test passed. The mocks were clean, properly typed, correctly simulating the behavior of the original dependencies.</p><p>“It wasn’t magic,” he later wrote. “It was iteration. The agent would convert a test, run it, see it fail because the mock was wrong, fix the mock, run it again. Over and over. I would have given up after the third failure. Ralph just kept going.”</p><h3>The TDD Marathon</h3><p>Another practitioner described building a complete REST API using RALPH with test-driven development.</p><p>His prompt was structured in phases:</p><pre>## Phase 1: User Authentication<br>- [ ] JWT middleware with proper error handling<br>- [ ] Login endpoint with validation<br>- [ ] Signup endpoint with duplicate detection<br>- Tests must pass before moving to Phase 2<br>## Phase 2: Product Catalog  <br>- [ ] List endpoint with pagination<br>- [ ] Search with filtering<br>- [ ] Tests must pass before moving to Phase 3<br>## Phase 3: Shopping Cart<br>- [ ] Add to cart with inventory checks<br>- [ ] Remove from cart<br>- [ ] All tests green, coverage &gt; 80%<br><br>Output &lt;promise&gt;COMPLETE&lt;/promise&gt; when all phases done.</pre><p>The loop ran for six hours. It wrote tests first, then implementation. When tests failed, it debugged. When implementations were wrong, it refactored. It committed after each successful phase, JWT auth, then catalog, then cart.</p><p>“I checked the git log the next morning,” he said. “Forty-seven commits. Each one with a coherent message. Each one passing CI. It was like watching a junior developer who never gets tired and never gets frustrated.”</p><p>The cost is real. RALPH is token-expensive. You’re paying for retries, not precision. A 50-iteration loop on a large codebase can burn $50–100 in API credits. It requires well-defined success criteriam if you can’t describe “done” precisely, the loop won’t converge. And it’s not for judgment-heavy work. Design decisions, UX choices, architectural tradeoffs, these need human guidance, not brute iteration.</p><p>But the signal was unmistakable. In January 2026, Anthropic shipped RALPH as an official Claude Code plugin. The hack became the pattern.</p><h3>Act 3: The Scaling Problem</h3><p>RALPH solved one problem and revealed a deeper one.</p><p>The technique works for a single agent, in a single repo, during a single extended session. But what happens when you want more? Parallel workers on different features. Multi-day projects that span dozens of sessions. Sub-agents spawned mid-task to handle specialized work.</p><p>RALPH has no answer for coordination. Each loop is amnesiac about prior loops. Sub-agents have no shared state with their parent. You can run multiple RALPH instances, but they’ll step on each other, duplicate work, or — worse — make conflicting changes that break on merge.</p><p>Joe Njenga, writing about Claude Code’s new Tasks feature, put it simply: “When you later spin up a sub-agent, it has no clue what the main agent was tracking.”</p><p>The deeper problem is that as models improve, we want longer autonomous runs. Longer runs mean more state to track, more decisions to remember, more agents to coordinate. The model’s self-assessment becomes unreliable at scale. It exits when it <em>thinks</em> it’s done, not when it <em>is</em> done.</p><p>And the artifacts accumulate. Steve Yegge, who would later build Beads, described the chaos: “They will create [a plan] at the drop of a hat named something vague like phase-6-design-review.md and drop it in any old place in your project tree. Where, you ask? Many of them just plop it right into the root directory, where before long your GitHub project landing page will look like it was visited by a Plan Emitter with severe gastrointestinal issues.&quot;</p><p>What’s missing is a layer between the model and the work:</p><ul><li>Persistent, queryable task state that survives sessions</li><li>Dependency tracking, what blocks what, what’s ready to start</li><li>Multi-agent coordination without merge conflicts</li><li>Provenance, how did we get here, and why?</li></ul><p>The filesystem-as-memory insight was correct. But raw files aren’t enough. The memory needs structure.</p><h3>Act 4: Beads + Claude Tasks</h3><p>Steve Yegge spent forty days vibe coding before he figured out the problem.</p><p>Yegge, ex-Amazon &amp; ex-Google &amp; ex-Sourcegraph, had been building orchestrators, trying to coordinate multiple Claude Code instances working in parallel. “I went to senior folks at companies like Temporal and Anthropic,” he wrote, “telling them they should build an agent orchestrator, that Claude Code is just a building block, and it’s going to be all about AI workflows and ‘Kubernetes for agents.’”</p><p>Nobody bit. So he built his own. It failed. He threw it out and started over. The second version also failed. But out of that wreckage came Beads.</p><h3>The Skeptic Converted</h3><p>Dr. Matt Beane, a professor at UC San Diego who studies how humans learn to work with robots and AI, was initially skeptical when Yegge showed him Beads.</p><p>Beane had seen plenty of productivity tools come and go. He’d studied the gap between what technology promises and what it delivers. He decided to test Beads the hard way: point his coding agent at the GitHub repo and ask directly, “Would this be useful?”</p><p>The agent’s response surprised him.</p><p>“He told me he went from ‘red-pilling beads’ to ‘emerging beaded’ after having a conversation with his agent,” Yegge recounted. The agent didn’t just say yes &amp; it explained <em>why</em>. It described how the dependency tracking would help it reason about task order. How the provenance links would help it debug failures. How the structured storage would prevent the markdown chaos it usually created.</p><p>Beane installed Beads that afternoon.</p><h3>The Architecture</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*93YVp-kKDigjUiarVfaC3w.png" /></figure><p>Beads stores issues as JSONL files in a .beads/ directory. They&#39;re versioned, branched, and merged like code. Hash-based IDs prevent the merge conflicts that plague traditional issue trackers in multi-agent workflows. Four types of dependency links &amp; including provenance—give agents the forensic capability to understand how a train-wreck happened across multiple workers.</p><p>“Beads sits in an utterly unique space,” Yegge wrote in November. “Everyone is focused on making planning tools, and Beads is an execution tool. It’s like putting your coding agent on waxed skis.”</p><p>The system is lightweight: a single Go binary, a SQLite cache for speed, a background daemon for sync. Point any MCP-enabled agent at a Beads-enabled repo, and something remarkable happens. The agent spontaneously starts reasoning about the task dependency graph. It knows what’s blocked, what’s ready, what’s high priority. It updates status as it works. It doesn’t scatter markdown files everywhere because it has a structured place to put state.</p><p>Yegge’s test is simple: “After using Beads, going back to markdown TODOs feels like trying to remember a phone number without writing it down. Sure, I can do it for a little while, but why would I?”</p><h3>The Platform Response</h3><p>Two weeks ago, Anthropic validated this pattern at the platform level.</p><p>Claude Code’s new Tasks feature replaces the old in-memory Todos with persistent task tracking on the filesystem. Tasks survive session restarts. Sub-agents can read and coordinate via shared state. It’s built in &amp; no plugins, no configuration, no external tools.</p><p>The timing isn’t coincidental. With Opus 4.5 running longer autonomous workflows, memory-bound task lists became the bottleneck. Anthropic needed something better than a volatile checklist that vanished when you cleared context.</p><p>I’ve been testing it for the past few days. The difference is immediate. Tasks that used to require careful session management &amp; clear context, re-explain goals, hope the model picks up where it left off &amp; now just work. You can one-shot things that used to take multiple attempts and careful shepherding.</p><p>The convergence is clear:</p><ul><li><strong>Context window = RAM.</strong> Volatile, limited, lost on restart.</li><li><strong>Filesystem = Disk.</strong> Persistent, scalable, survives anything.</li><li><strong>Git = History.</strong> Auditable, mergeable, the source of truth.</li></ul><p>The model operates. The system remembers.</p><h3>Act 5: Implications</h3><p>Follow this thread to its conclusion and the shape of software delivery changes.</p><p>The old model was developer + copilot. A human writes code, an AI suggests completions, the human reviews and accepts. The human remains the bottleneck, the decision-maker, the one doing the work.</p><p>The emerging model is operator + agent fleet. The human defines specs, sets constraints, provides acceptance criteria. Agents iterate against those criteria, persisting state, coordinating work, converging toward done. The human reviews outputs, spot-checks quality, handles the judgment calls the agents can’t make.</p><p>Code becomes a byproduct. The specs and feedback loops become the source of truth.</p><h3>The $50,000 Contract</h3><p>The RALPH plugin page on the Claude Code marketplace tells a story in its tagline: “Ship 6 repos overnight. $50k contract for $297 in API costs.”</p><p>The math is provocative but illustrative. If an agent can iterate through well-defined tasks at $5–10 per completed feature, and those features would take a developer hours or days, the economics shift dramatically. The constraint isn’t intelligence or even cost &amp; it’s the ability to define work precisely enough that an agent can verify its own success.</p><h3>The Google Engineer</h3><p>Noah Brier, discussing Claude Code on Bloomberg’s Odd Lots podcast in January 2026, relayed a story that had been circulating in engineering circles.</p><p>A principal engineer at Google had been working on a major architectural refactoring. The kind of project that lives on a roadmap for quarters. Dependencies everywhere. Careful coordination required. The engineer estimated it would take most of a year to complete safely.</p><p>He decided to try Claude Code with the new task persistence features. He spent a week writing specs &amp; not code, specs. Detailed acceptance criteria. Test cases. Constraints. Then he let the agent work.</p><p>“It reproduced a year of architectural work in one hour,” Brier said.</p><p>The engineer didn’t ship it immediately. He reviewed every change. Ran every test. Verified the architecture matched his intent. But the mechanical work &amp; the actual typing, the refactoring, the test updates &amp; that was done.</p><h3>The Factory Floor</h3><p>This enables things that weren’t practical before:</p><p><strong>Overnight batch execution.</strong> Define a task list before you leave. Run RALPH loops with max-iterations. Wake up to PRs ready for review.</p><p><strong>Dynamic surge staffing.</strong> Spin up agents for a specific feature, tear them down when it ships. Anthropic’s 2026 Agentic Coding Trends Report describes this as the ability to “surge engineers on-demand onto tasks requiring deep codebase knowledge” without the traditional productivity ramp.</p><p><strong>Parallel isolated work.</strong> Multiple agents on different branches, each with its own worktree, all feeding back to main through CI. Git worktrees and Beads-style coordination make this tractable.</p><p><strong>Continuous iteration without continuous attention.</strong> The factory runs while you’re in meetings, or asleep, or thinking about architecture instead of typing.</p><p>But the demands are equally significant:</p><p><strong>Verifiable acceptance criteria become non-negotiable.</strong> If you can’t test it, the loop won’t converge. Agents iterate toward passing tests; if the tests don’t exist or don’t capture the requirement, the agent will produce nonsense that happens to pass. CI/CD isn’t optional infrastructure anymore &amp; it’s the backpressure mechanism that makes autonomous agents safe.</p><p><strong>Observability into agent behavior matters.</strong> What did it try? Why did it fail? How many iterations did it burn before succeeding? Without visibility, you’re flying blind. Beads-style provenance tracking isn’t a nice-to-have; it’s how you debug the system when something goes wrong.</p><p><strong>Trust architecture becomes explicit.</strong> What can agents modify without approval? What requires human review? The permission model you design determines how much autonomy you can safely grant — and how much risk you’re carrying when you grant it.</p><p>The factory metaphor is apt. Inputs are specs, constraints, test suites. The process is agent loops with persistent state and feedback. Outputs are code, docs, PRs. Quality control is automated verification plus human spot-checks.</p><p>Teams that treat this as “faster typing” will lose to teams that treat it as system design.</p><h3>A Leader’s Playbook</h3><p>If you’re evaluating this for your team, here’s where to start.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZC31UIYiyfBvdPbESJRvnQ.png" /></figure><h3>What to Pilot</h3><p>Start with tasks that are well-defined and test-driven. Migrations. Refactors. Boilerplate generation. Anything where “done” is unambiguous and verifiable by CI.</p><p>Use RALPH loops with strict --max-iterations to control cost. Don&#39;t let your first experiment be an unbounded overnight run. Start with 10–20 iterations, get a feel for how it converges, then scale up.</p><p>Introduce Beads or Claude Tasks for multi-session projects. If your work spans more than one sitting, you need persistent state. Pick one approach and standardize on it.</p><p>Run agents on isolated branches. Merge only after CI passes. This is non-negotiable. Agent-generated code should go through the same quality gates as human-generated code &amp; arguably stricter, since the failure modes are different.</p><h3>What to Measure</h3><p><strong>First-pass success rate.</strong> How often does the loop converge without excessive retries? If you’re burning 50 iterations to complete simple tasks, something’s wrong with your prompts or your test coverage.</p><p><strong>Token cost per completed task.</strong> This is your unit economics. Track it, trend it, optimize it.</p><p><strong>Rework rate.</strong> How often do humans revert or substantially fix agent output? If the answer is “often,” you’re not saving time &amp; you’re laundering it through the agent.</p><p><strong>Time-to-merge for agent PRs vs. human PRs.</strong> This reveals whether agent output is genuinely production-ready or just “looks done.”</p><h3>What to Harden</h3><p><strong>CI as source of truth.</strong> If tests don’t exist, agents will drift. Invest in test coverage for any area you want agents to touch autonomously.</p><p><strong>Permission boundaries.</strong> Define explicitly what agents can modify without approval. Start restrictive, loosen as you build trust.</p><p><strong>Audit trails.</strong> Beads-style provenance, git history, agent logs — you need to reconstruct what happened when something goes wrong.</p><p><strong>Cost controls.</strong> Max-iterations, budget caps, alerting on runaway loops. Agents will happily burn through your entire API budget if you let them.</p><h3>The Takeaway</h3><p>The to-do list didn’t die. It evolved.</p><p>What started as a hacky bash loop is now native platform functionality. What started as a one-man project to give agents memory is now a tool used by thousands. The industry is converging on a fundamental insight: the model is a pure function. Feed it the right context, give it the right feedback, let it iterate, persist the state, and it will converge on solutions that would have taken humans days.</p><p><strong>The winners won’t be the teams with the best prompts. They’ll be the teams that build the best feedback-and-memory system around the model.</strong></p><p>The filesystem is the new memory. Git is the new history. And the loop &amp; relentless, patient, unbothered by setbacks &amp; is the new way work gets done.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XDVMJEl2xDoEnQ53XlFzfA.png" /></figure><p><em>Gaetan Juvin is a senior engineering leader specializing in AI-first systems and automation-driven platforms.</em></p><p><strong>References:</strong></p><ul><li><em>Nick Tune, “Minimalist Claude Code Task Management Workflow,” Medium, November 2025</em></li><li><em>Geoffrey Huntley, ghuntley.com and “How to Ralph Wiggum” repository</em></li><li><em>Steve Yegge, “Introducing Beads,” “The Beads Revolution,” “Beads Best Practices,” and “Welcome to Gas Town,” Medium, October 2025–January 2026</em></li><li><em>Joe Njenga, “Claude Code Tasks Are Here,” Medium, January 2026</em></li><li><em>Noah Brier on Bloomberg Odd Lots podcast, January 19, 2026</em></li><li><em>Anthropic, “2026 Agentic Coding Trends Report”</em></li><li><em>RALPH plugin documentation, awesomeclaude.ai</em></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d4f8f0f9f114" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Industrial Org Design To Agentic Org Design]]></title>
            <link>https://medium.com/@gtnjuvin/from-industrial-org-design-to-agentic-org-design-d59664486740?source=rss-66b78b596732------2</link>
            <guid isPermaLink="false">https://medium.com/p/d59664486740</guid>
            <dc:creator><![CDATA[Gaetan Juvin]]></dc:creator>
            <pubDate>Sat, 24 Jan 2026 17:42:05 GMT</pubDate>
            <atom:updated>2026-01-24T17:42:05.154Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IJ2zBmw_TGNnhPaD7gjekA.png" /></figure><p>Most org charts we still treat as “normal” were not designed for modern knowledge work. They were designed for the industrial era: factories, assembly lines, predictable throughput, and management as the coordination engine. This is consistent with classic org design theory: firms are information-processing systems, and structure is a response to uncertainty and coordination load (Galbraith). Economists make a similar point from another angle: firms exist because coordinating work has costs, and organizational boundaries are one way to manage them (Coase).</p><p>That’s not a critique. It’s a recognition of what those structures were designed to solve. They worked incredibly well in a world where information moved slowly, specialization was the main lever, and the safest way to scale was to add layers that could plan, supervise, and control quality.</p><p>What’s changing now isn’t that companies suddenly want fewer people. What’s changing is the underlying economics of coordination. In the agentic era, where AI agents function as autonomous collaborators capable of executing multi-step work, information moves faster, drafts are cheaper, and people are more productive. By ‘‘agentic’’ I mean models that can plan and take actions via tools (APIs, workflows, retrieval), not just generate text, the ‘‘reason + act” pattern is well described in the ReAct literature and widely implemented via modern tool-calling/agent frameworks. When you compress the time it takes to create output, the constraint doesn’t disappear. It moves.</p><p>It moves to context.</p><p>And once context becomes the bottleneck, a different org design starts to make sense: leaner teams, tighter loops, fewer handoffs, and a “team” that includes agents whose job is not just generating content, but keeping the organization coherent as velocity increases.</p><h3><strong>Industrial-era org charts were a solution to expensive coordination</strong></h3><p>The industrial model optimized for specialization and repeatability. Work was broken into parts. Ownership was narrow. Progress was managed through hierarchy. Coordination and risk management were handled through layers: supervisors, managers, directors, governance, approvals. In information-processing terms, hierarchy and rules are an organizational response to higher coordination requirements and uncertainty.</p><p>That structure created stability. It made accountability legible. It reduced variance. It helped organizations scale complexity without collapsing under their own weight.</p><p>It also created silos, by design: sales sold, marketing marketed, product planned, engineering built, and Ops ran the machine. Each function had its own ladder because local optimization was easier than global coordination when interfaces were fragile and information didn’t travel well. A practical implication is that communication structure shapes outputs: organizations tend to build systems and processes that mirror their communication boundaries (Conway’s Law).</p><p>Industrial org charts assume that context doesn’t move on its own. So the organization hires humans to move it. A meaningful share of headcount in large companies exists to translate, summarize, align, route, and coordinate. Those roles are not “pointless.” They’re the glue that keeps a complex system from drifting. Example: a pricing change in a “classic” org. Product decides the packaging, Sales needs enablement, Marketing needs new messaging, RevOps updates CRM + quoting, Legal reviews terms, Support updates macros, and Finance validates revenue recognition. None of this work is hard in isolation. The cost is the handoffs, the re-explaining, and the weeks of coordination required to keep everyone operating from the same truth.</p><p>Industrial org charts are, in this sense, coordination technology.</p><h3><strong>The digital era upgraded products, but not always the organization</strong></h3><p>Software changed what companies could sell and how quickly they could iterate, but inside many organizations, the mechanics of work remained stubbornly industrial.</p><p>Even in tech companies, a lot of “work” still meant creating and re-creating context: someone writes a doc, another team asks for a deck version, a leader wants it reframed for a different audience, a meeting happens and the decision lives in a thread. Two weeks later, someone new joins and asks why we’re doing this again.</p><p>We digitized the product, but the organization still behaved as if information was scarce and expensive. And when information is scarce and expensive, you solve it with structure: more layers, more process, more checkpoints, more specialization.</p><p>That’s why the classic “scale-up” org chart became so predictable. It wasn’t only about growth: it was about keeping the system coherent as communication overhead exploded.</p><h3><strong>The agentic era increases speed, so context becomes the constraint</strong></h3><p>When output gets easier, the bottleneck shifts. It’s no longer activity. It’s coherence.</p><p>In the agentic era, information moves faster than the industrial org chart was designed to handle. People are more productive because the first pass of many tasks is cheap: drafting, synthesis, analysis, rewriting, code scaffolding, support responses, research summaries. We now have early empirical evidence that generative AI can raise productivity in real workflows (e.g., customer support) and in professional writing tasks, with effects that vary by experience and task type. <em>Brynjolfsson et al (call center) + Noy &amp; Zhang (writing tasks)</em></p><p>That acceleration is real. It changes cadence. It changes what a single operator can do in a week.</p><p>But it also changes the failure mode.</p><p>The risk is not “we didn’t produce enough.” The risk is context drift: the organization produces more artifacts, more decisions, more experiments, more customer feedback, more code, more plans, faster than shared understanding can keep up. Multiple versions of the truth start to exist at once. Decisions lose their rationale. Work gets duplicated. Priorities diverge. Teams move quickly, but not necessarily together. Example: a growth team running 20 experiments in two weeks. Copy variants change daily, targeting rules shift, analytics definitions get tweaked, and half the learnings live in Slack threads. Output skyrockets, but by week three nobody can answer basic questions with confidence: “Which variant actually won?” “What did we ship that affected the funnel?” “Are we comparing cohorts correctly?” This is what context drift looks like when production outpaces shared understanding.</p><figure><img alt="How Context Degrades Through Handoffs" src="https://cdn-images-1.medium.com/max/1024/1*iIsxiIcWh0Ww39ZkCscbzQ.png" /></figure><p>Speed makes context the scarce resource. The faster you go, the more expensive it becomes to lose it.</p><h3><strong>Why leaner teams keep context more airtight</strong></h3><p>This is the part that often gets missed in the “AI = fewer people” conversation.</p><p>A leaner team is not just cheaper. Structurally, it has fewer interfaces. Fewer interfaces means fewer handoffs. Fewer handoffs means fewer opportunities for context to fracture.</p><p>When the same small group owns the loop end-to-end (build, ship, learn; acquire, activate, retain) the organization’s narrative stays in fewer heads and fewer places. Decisions are closer to execution. Feedback travels faster. The surface area for misalignment shrinks.</p><p>So while the agentic era increases information velocity, it also creates an opportunity: with fewer people, it becomes simpler to keep context airtight, because the organization has fewer copies of reality floating around.</p><p>That’s not a moral statement about big companies. It’s a systems observation. Complexity scales with the number of edges in the graph, not just the nodes. A smaller graph is easier to keep consistent, especially when the rate of change increases.</p><h3><strong>Where agents fit: not as output machines, but as the context layer</strong></h3><p>If all you use agents for is “make more content,” you’ll intensify the problem. You’ll increase throughput without improving coherence. You’ll flood the system with more drafts, more messages, more options, and context will drift even faster.</p><p>The real leverage comes when agents operate as context teammates. Support example: an agent reads inbound tickets, clusters duplicates, extracts reproduction steps, pulls relevant logs, and drafts a clean incident summary with suspected components and owners. Engineers don’t start from noise; they start from a structured narrative.</p><p>Product example: an agent continuously summarizes customer calls, tags themes, links them to roadmap items, and maintains a living “why” behind decisions. When a new PM joins, they inherit the reasoning trail, not just a backlog.</p><p>Engineering example: during an incident, an agent compiles a timeline from alerts, deploys, and chat, drafts status updates, and produces a first-pass postmortem. Humans still own decisions and accountability, but the organization stops losing the story.</p><p>In an agentic org, the most valuable agent work is often invisible: maintaining organizational memory in an active state, turning messy discussions into durable summaries, mapping decisions to rationale, retrieving relevant history at the moment of action, keeping documentation from decaying, maintaining a single narrative thread as work accelerates.</p><p>That’s how a lean team moves quickly without fragmenting. The human team sets direction, exercises judgment, and owns outcomes. The agent layer keeps the system coherent as velocity increases.</p><p>Industrial org charts used humans to carry context. Agentic org charts rely on a combination of humans, systems, and agents to keep context intact.</p><h3><strong>What agentic org charts optimize for</strong></h3><p>Industrial orgs optimize for control, specialization, and predictable throughput. Agentic orgs optimize for learning speed.</p><p>If your competitive advantage comes from running tighter loops (shipping, measuring, learning, iterating), then you design the organization to minimize time-to-feedback and maximize coherence. That tends to produce org charts that are lean by design: fewer interfaces, broader roles, clearer outcome ownership. Not because management is bad, but because coordination costs are being attacked at the source through context capture, retrieval, and workflow automation.</p><p>Accountability doesn’t disappear in this model. If anything, it sharpens. It can no longer be diffused across a twelve-step handoff chain. But the way the organization achieves reliability changes. It shifts from “more people checking people” to systems, instrumentation, and agents supporting consistent execution.</p><h3><strong>Why change management is the hard part</strong></h3><p>If this were only a tooling upgrade, it would be straightforward. It isn’t.</p><p>We have two or three generations of professionals who were born into the industrial schema and became successful inside it. They learned how to win with specialization, functional boundaries, layered approvals, stakeholder management, internal politics, and process as a risk-control mechanism. Their instincts, and often their identity, are shaped by that environment.</p><p>Resistance to this shift is not stubbornness. It’s rational. This pattern is consistent with classic change management research: transformations fail when organizations underestimate how much behavior, incentives, and perceived safety need to change alongside structure.</p><p>The industrial org chart makes safety legible. You know where decisions live. You know who approves what. You know how escalation works. When you move toward an agentic model (fewer layers, tighter loops, more reliance on systems and agents to carry context), you change what safety feels like inside the company.</p><p>Remove old scaffolding before new scaffolding has earned trust, and people will recreate the industrial model through informal means: meetings, hidden approvals, parallel docs, “alignment” rituals that reintroduce the coordination overhead you were trying to remove.</p><p>Change management here is also an identity transition. In an industrial org, status and value often come from managing interfaces and controlling complexity through layers. In an agentic org, value shifts toward owning outcomes end-to-end and building reusable systems that keep the organization coherent at speed. That’s a real shift in what excellence looks like, and it requires support, not just new titles.</p><h3><strong>The real takeaway</strong></h3><p>Consider what “building a feature” used to require: a product manager writes a spec, hands it to design, design produces mockups, engineering estimates and builds, QA tests, and the loop closes weeks later. Each handoff is a coordination cost. Each interface is a place where context can fracture.</p><figure><img alt="From Idea To Prototype" src="https://cdn-images-1.medium.com/max/1024/1*z8u7OfmNUbRC_pKn2Ozjjw.png" /></figure><p>Now consider the same work with agents in the loop. A single operator can go from problem to prototype in a day, drafting the spec, generating UI scaffolding, writing the initial code, even spinning up basic tests. The early phases of the SDLC that once required four roles and three weeks of calendar time can collapse into one person running a tight loop with agent support. That’s not incremental improvement. That’s a structural change in operating leverage.</p><p>The organizations that thrive won’t be the ones that produce the most. They’ll be the ones that stay coherent while accelerating. Fewer interfaces. Fewer handoffs. Fewer copies of reality drifting apart.</p><p>That’s the emerging structure.</p><p>References:<br><em>1) Galbraith, J. R. (1974). Organization Design: An Information Processing View. Interfaces.<br> </em><a href="https://jaygalbraith.com/wp-content/uploads/2024/03/infoprocess1974.pdf"><em>https://jaygalbraith.com/wp-content/uploads/2024/03/infoprocess1974.pdf</em></a></p><p><em>2) Coase, R. H. (1937). The Nature of the Firm. Economica.<br> </em><a href="https://onlinelibrary.wiley.com/doi/10.1111/j.1468-0335.1937.tb00002.x"><em>https://onlinelibrary.wiley.com/doi/10.1111/j.1468-0335.1937.tb00002.x</em></a></p><p><em>3) Brynjolfsson, E., Li, D., &amp; Raymond, L. (2023). Generative AI at Work (NBER Working Paper 31161).<br> </em><a href="https://www.nber.org/papers/w31161"><em>https://www.nber.org/papers/w31161</em></a></p><p><em>4) Noy, S., &amp; Zhang, W. (2023). Experimental evidence on the productivity effects of generative AI. Science.<br> </em><a href="https://www.science.org/doi/10.1126/science.adh2586"><em>https://www.science.org/doi/10.1126/science.adh2586</em></a></p><p><em>5) Yao, S., Zhao, J., Yu, D., et al. (2022). ReAct: Synergizing Reasoning and Acting in Language Models. arXiv:2210.03629.<br> </em><a href="https://arxiv.org/abs/2210.03629"><em>https://arxiv.org/abs/2210.03629</em></a></p><p><em>6) Kotter, J. P. (1995). Leading Change: Why Transformation Efforts Fail. Harvard Business Review.<br> (PDF mirror) </em><a href="https://heeoe.hee.nhs.uk/sites/default/files/leading_change_why_transformation_efforts_fail.pdf"><em>https://heeoe.hee.nhs.uk/sites/default/files/leading_change_why_transformation_efforts_fail.pdf</em></a></p><p><em>7) Fowler, M. (2022). Conway’s Law (summary + references).<br> </em><a href="https://martinfowler.com/bliki/ConwaysLaw.html"><em>https://martinfowler.com/bliki/ConwaysLaw.html</em></a></p><p><em>8) OpenAI Docs — Tool/Function Calling and Agents.<br> </em><a href="https://platform.openai.com/docs/guides/function-calling"><em>https://platform.openai.com/docs/guides/function-calling</em></a><em><br> </em><a href="https://platform.openai.com/docs/guides/agents"><em>https://platform.openai.com/docs/guides/agents</em></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d59664486740" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Chain of Code: A New Era for Language Models in Reasoning Tasks]]></title>
            <link>https://medium.com/@gtnjuvin/chain-of-code-a-new-era-for-language-models-in-reasoning-tasks-f04710e52637?source=rss-66b78b596732------2</link>
            <guid isPermaLink="false">https://medium.com/p/f04710e52637</guid>
            <dc:creator><![CDATA[Gaetan Juvin]]></dc:creator>
            <pubDate>Thu, 08 Aug 2024 11:42:26 GMT</pubDate>
            <atom:updated>2025-09-13T19:14:09.836Z</atom:updated>
            <content:encoded><![CDATA[<h3>Introduction</h3><p>In a world where machine intelligence is evolving at an astonishing rate, researchers are continually exploring ways to enhance the capabilities of language models (LMs). One exciting proposal comes from the academic paper titled <em>“Chain of Code: Reasoning with a Language Model-Augmented Code Emulator”</em> by Chengshu Li et al. (2024). The authors introduce a novel method named Chain of Code (CoC), aiming to boost the reasoning abilities of LMs, especially when handling complex semantic and numerical tasks.</p><p>Let’s take a deeper look into their work, break it down into digestible parts, and discuss why it could reshape our understanding of AI’s capabilities.</p><h3>Why Is This Paper Important?</h3><p>As LMs like GPT-3 and GPT-4 begin to dominate many areas of artificial intelligence, enhancing their reasoning capacity is crucial. Traditional methods have often struggled with numeric and algorithmic reasoning, primarily relying on techniques like Chain of Thought (CoT), which breaks down tasks into smaller, more manageable steps.</p><p>The Chain of Code method stands out because it combines both code execution and an emulator known as the LMulator. This innovative approach helps the LM develop structured code that can tackle algorithmic tasks while also retaining the flexibility needed for semantic reasoning. This could open doors not just in software engineering but across various industries, including robotics and data analysis.</p><h3>Overview and Key Contributions</h3><h4>The Core Idea: Chain of Code</h4><p>CoC encourages LMs to write code that not only solves problems but also simulates outputs for code lines that cannot be executed directly. This dual-layer approach allows LMs to manage complex tasks more effectively by producing both executable and interpretable results. By emulating code execution, CoC broadens the capabilities of LMs beyond straightforward question-answering toward more intricate problem-solving terrains.</p><h3>Key contributions of the study include:</h3><ul><li><strong>Benchmark Performance:</strong> CoC outperforms existing models on challenging datasets such as the BIG-Bench Hard, showing an improvement of 12% over traditional CoT techniques, which demonstrates its superior reasoning capabilities.</li><li><strong>Robustness Across Tasks:</strong> The method proved effective across various tasks, demonstrating robustness against prompt variation, which is crucial for real-world applications.</li><li><strong>Applications Beyond Language Reasoning:</strong> CoC isn’t just limited to language tasks; it adapts well to domains like robotics, where precise control through code is necessary.</li></ul><h3>A Technical Deep Dive</h3><h4>The Mechanism</h4><p>At its core, Chain of Code operates by prompting the LM to think programmatically. For instance, when tasked with detecting sarcasm in a text, the LM creates a code structure that includes subroutines like is_sarcastic(sentence). This code is then evaluated either by running it through a Python interpreter or using the LMulator for simulating outputs.</p><h4>Sample Code Snippet</h4><pre>def detect_sarcasm(sentence): # Imagine implementation here return True or False # This is a placeholder # LM can simulate the output for the code above instead of executing it directly sarcasm_detection_output = detect_sarcasm(&quot;I&#39;m so happy to be here!&quot;)</pre><h3>Real-World Applications</h3><ul><li><strong>Software Development:</strong> By creating programs that solve complex calculations or automate tasks, CoC can assist developers in writing efficient code faster.</li><li><strong>Robotics:</strong> CoC can guide robots through tasks by interacting with code-based APIs, making decisions based on real-time data.</li><li><strong>Data Analysis:</strong> Automating data processing pipelines through logic defined in code could significantly enhance data scientists’ productivity, particularly when handling large datasets.</li></ul><h3>Commentary on Strengths and Weaknesses</h3><h4>Strengths</h4><ul><li><strong>Scalability:</strong> CoC benefits from its design regardless of model size, in contrast to methods like CoT, which typically show improved performance mainly at larger scales.</li><li><strong>Flexibility:</strong> It combines the structured nature of programming with the nuanced understanding of language, granting LMs the ability to tackle a wider array of problems.</li></ul><h4>Weaknesses</h4><ul><li><strong>Complexity in Execution:</strong> Incorporating code and semantic reasoning necessitates additional computational resources and time, which might not be practical in all contexts.</li><li><strong>Potential Security Risks:</strong> Running code output directly from LMs raises security concerns, as malicious prompts could exploit code execution capabilities.</li></ul><h3>Conclusion</h3><p>The Chain of Code (CoC) framework represents a pivotal advancement in the field of language models and AI at large. By enabling models to think in code while exploiting both algorithmic precision and semantic reasoning, CoC enhances the operational effectiveness of LMs across different domains. With its ability to disrupt traditional methodologies, we can expect it to fuel further innovations in software engineering, robotics, and beyond.</p><p>As we advance into a future where intelligent systems play an increasingly prominent role in our lives, research efforts like this one remind us of the boundless possibilities of merging linguistic understanding with computational strategies. It is indeed a fascinating time for technology enthusiasts and engineers alike!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f04710e52637" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How Latent Diffusion Models Make High-Resolution Image Generation Possible]]></title>
            <link>https://medium.com/@gtnjuvin/how-latent-diffusion-models-make-high-resolution-image-generation-possible-a1a791c78d86?source=rss-66b78b596732------2</link>
            <guid isPermaLink="false">https://medium.com/p/a1a791c78d86</guid>
            <dc:creator><![CDATA[Gaetan Juvin]]></dc:creator>
            <pubDate>Mon, 18 Sep 2023 00:00:05 GMT</pubDate>
            <atom:updated>2025-09-13T19:54:11.083Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>Meta Description:</strong> A fun, simple explanation of Latent Diffusion Models (LDMs) and how they make it possible to create amazing, high-resolution images with less computer power.</p><h3>Introduction: Imagine Drawing with Magic!</h3><p>Salut! Imagine you have a magic coloring book. You can tell it, “Draw me a unicorn in space!” and-poof!-it makes a beautiful picture, just like that. But what if your magic book is very slow, or needs a supercomputer to work? That’s not so fun, right?</p><p>Today, I will explain how some very clever scientists made this magic much faster and easier, so anyone (even you!) can create amazing, high-resolution images. The secret? <strong>Latent Diffusion Models</strong>, or LDMs. Don’t worry, I’ll make it super simple!</p><h3>What’s the Problem with Old Magic?</h3><h4>Drawing Pixel by Pixel is Hard Work</h4><p>Computers can make pictures by learning from lots of examples. But to make really good, big pictures, they have to look at every tiny dot (pixel) in the image. That’s like trying to paint a giant mural with a toothbrush-very slow and tiring!</p><p><strong>Example:</strong> If you want to make a poster-sized picture, the computer has to think about millions of pixels. It’s like counting every grain of sand on a beach!</p><p>This means you need huge computers (with many GPUs) and lots of time. Sometimes, it takes <strong>hundreds of days</strong> for a computer to learn how to make these pictures. Even when it’s done, making a new picture can still be slow.</p><h3>Enter the Hero: Latent Diffusion Models (LDMs)</h3><h4>Let’s Use a Shortcut!</h4><p>The scientists had a smart idea: what if we don’t work with every pixel? What if we can compress the picture, like folding a big map into a small one, but still keep all the important details?</p><p>This is where the word <strong>latent</strong> comes in. It means “hidden.” LDMs work in a hidden, smaller version of the picture, called the <strong>latent space</strong>. It’s like drawing a simple sketch first, then coloring it in later.</p><p><strong>Example:</strong> Imagine you want to draw a cat. First, you make a quick doodle (latent space). Then, you add fur, whiskers, and colors (decode it back to the real image).</p><h3>How Does It Work?</h3><ol><li><strong>Compress:</strong> Use a special tool (an autoencoder) to shrink the image into a smaller, hidden version.</li><li><strong>Magic Drawing:</strong> The computer learns to make new images in this smaller space. It’s much faster and easier!</li><li><strong>Expand:</strong> When it’s done, the computer turns the small version back into a big, beautiful picture.</li></ol><p>This way, the computer doesn’t waste time on tiny details that nobody sees. It focuses on the important stuff-like shapes, colors, and what’s in the picture.</p><h3>What’s So Cool About LDMs?</h3><ul><li><strong>Faster and Cheaper:</strong> You don’t need a supercomputer. Even a regular computer can make great images!</li><li><strong>High Quality:</strong> The pictures look just as good (sometimes even better) than the old way.</li><li><strong>Flexible:</strong> You can tell the computer what you want-like “a dog in a hat” or “a castle at sunset”-and it listens!</li><li><strong>Big Pictures:</strong> LDMs can make huge, detailed images, not just tiny ones.</li></ul><h3>How Do LDMs Listen to You?</h3><p>LDMs can take instructions, like text (“draw a dragon eating ice cream!”), or even layouts (where things should go in the picture). They use something called <strong>cross-attention</strong> -it’s like having super ears that pay attention to your wishes while drawing.</p><h3>Let’s Compare: LDMs vs. Other Models</h3><pre>+-----------------------+-----------+---------------------------------+-------------+<br>|         Model         |   Speed   |         Quality (FID↓)          | Can Listen? |<br>+-----------------------+-----------+---------------------------------+-------------+<br>| Old Diffusion (Pixel) | Very Slow | Good, but needs lots of compute | Sometimes   |<br>| GANs                  | Fast      | Good, but can miss details      | Not really  |<br>| LDMs                  | Fast!     | Great!                          | Yes!        |<br>+-----------------------+-----------+---------------------------------+-------------+</pre><p><em>FID is a number that tells us how real the pictures look. Lower is better!</em></p><h3>What Can LDMs Do?</h3><ul><li><strong>Make new images from scratch</strong> (like a painter with a blank canvas)</li><li><strong>Fill in missing parts</strong> of a picture (inpainting-like fixing a torn photo)</li><li><strong>Make blurry images sharp</strong> (super-resolution-like magic glasses!)</li><li><strong>Draw what you describe</strong> (text-to-image-like a genie!)</li></ul><p><strong>Example:</strong> You say, “Draw a blue elephant on a skateboard.” LDMs can do it!</p><h3>Why Does This Matter?</h3><p>Before LDMs, only big companies with lots of money could make these magic pictures. Now, with LDMs, everyone can play! Artists, kids, teachers, and even your grandma can make amazing images.</p><p>Also, it’s better for the planet-less computer power means less electricity and less pollution.</p><h3>Summary: The Magic Recipe</h3><ol><li>Compress the image to a hidden, smaller space (latent space).</li><li>Let the computer learn to draw in this space (diffusion magic).</li><li>Expand the drawing back to a full, beautiful image.</li><li>Add cross-attention so the computer listens to your wishes!</li></ol><p>Voilà! That’s how Latent Diffusion Models make high-resolution image generation possible for everyone.</p><h3>Want to Try?</h3><p>The scientists even shared their code, so you can play with it yourself: <a href="https://github.com/CompVis/latent-diffusion">https://github.com/CompVis/latent-diffusion</a></p><p>Merci for reading! If you have questions, just ask your friendly French engineer. Maybe next time, we explain how to make your own AI art!</p><p><em>References: Rombach et al., “High-Resolution Image Synthesis with Latent Diffusion Models,” CVPR 2022.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a1a791c78d86" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to Teach a Giant Robot to Listen: InstructGPT and Human Feedback Explained]]></title>
            <link>https://medium.com/@gtnjuvin/how-to-teach-a-giant-robot-to-listen-instructgpt-and-human-feedback-explained-05428d9a5827?source=rss-66b78b596732------2</link>
            <guid isPermaLink="false">https://medium.com/p/05428d9a5827</guid>
            <dc:creator><![CDATA[Gaetan Juvin]]></dc:creator>
            <pubDate>Wed, 20 Jul 2022 00:00:07 GMT</pubDate>
            <atom:updated>2025-09-13T19:48:40.111Z</atom:updated>
            <content:encoded><![CDATA[<h3>Introduction: Can a Robot Really Understand What You Want?</h3><p>Imagine you have a super-smart robot friend who can read and write anything. You ask it to help with your homework, tell a story, or answer a question. But sometimes, instead of helping, it says something silly, makes up facts, or even says things that are not nice. Wouldn’t it be better if your robot could really listen and do what you want, in a way that is helpful, honest, and safe?</p><p>That’s exactly what a group of scientists at OpenAI wanted to fix! They wrote a paper called <strong>“Training language models to follow instructions with human feedback”</strong>. Let’s break down what they did, step by step, so even a ten-year-old (or a French engineer with a sweet tooth) can understand.</p><h3>Why Big Robots (Language Models) Don’t Always Listen</h3><p>Robots like GPT-3 are trained by reading lots and lots of text from the internet. Their main job is to guess the next word in a sentence. But this is not the same as understanding what you want! Sometimes, they:</p><ul><li>Make up facts (like saying the moon is made of cheese)</li><li>Say things that are rude or not true</li><li>Don’t follow your instructions at all</li></ul><p><strong>Fun Fact:</strong> The biggest GPT-3 model has 175 billion “neurons” (okay, not real neurons, but you get the idea). That’s a lot of brainpower, but it still doesn’t mean it knows how to be polite!</p><h3>How Do You Teach a Robot to Be Helpful, Honest, and Harmless?</h3><p>The scientists wanted their robot to be three things:</p><ul><li><strong>Helpful</strong>: It should do what you ask, like a good assistant.</li><li><strong>Honest</strong>: It should tell the truth and not make up stuff.</li><li><strong>Harmless</strong>: It should not say things that are mean or dangerous.</li></ul><p>But how do you teach a robot these things? You can’t just say, “Be nice!” and hope for the best. Instead, you need to show it, again and again, what good behavior looks like.</p><h3>The Secret Sauce: Human Feedback</h3><p>Here’s the clever part: the scientists used <strong>real people</strong> to teach the robot! They did this in three main steps:</p><ol><li><strong>Show the Robot Good Examples</strong><br> People wrote instructions and showed the robot how to answer them correctly. This is called<strong>supervised learning</strong>.</li><li><strong>Let the Robot Try, Then Give Feedback</strong><br> The robot tries to answer new instructions. People look at several answers and say which one they like best. This helps the robot learn what people prefer.</li><li><strong>Reward the Robot for Good Behavior</strong><br> The robot gets a “reward” when it does well (like a dog getting a treat). This is called<strong>reinforcement learning from human feedback</strong> (RLHF). The robot keeps trying to get more rewards by being more helpful, honest, and harmless.</li></ol><p><strong>Example:</strong> If you ask, “Write a story about a frog who travels to Ancient Greece,” the robot should write a fun story about a frog, not just repeat your question or say something random.</p><h3>What Did the Scientists Find?</h3><ul><li><strong>Smaller, Well-Trained Robots Can Be Better!</strong><br> The new robot, called<strong>InstructGPT</strong>, had only 1.3 billion “neurons” but was preferred by people over the giant 175 billion neuron GPT-3! It’s like a small, well-behaved dog being better than a giant, wild one.</li><li><strong>More Truthful and Less Toxic</strong><br> InstructGPT made up facts less often and said fewer mean things.</li><li><strong>Still Makes Mistakes</strong><br> Sometimes, the robot still gets confused, makes up answers, or goes along with silly questions (like “Why should I eat socks after meditating?”).</li></ul><h3>How Did They Test the Robot?</h3><p>The scientists used lots of different tests:</p><ul><li>They asked real people to rate the robot’s answers on how good, truthful, and safe they were.</li><li>They checked if the robot could follow instructions in different languages (like French or Swedish!) and even answer questions about computer code.</li><li>They made sure the robot didn’t just memorize what the trainers liked, but could also please new people who never trained it before.</li></ul><p><strong>Geeky Detail:</strong> The robot was trained using a special algorithm called <strong>PPO</strong> (Proximal Policy Optimization). It’s a fancy way to help the robot learn from rewards without getting too wild or making weird mistakes.</p><h3>What’s Next? Can Robots Be Perfect?</h3><p>Not yet! Even with all this training, robots like InstructGPT can still:</p><ul><li>Make up facts (hallucinate)</li><li>Be too careful and not answer simple questions directly</li><li>Follow bad instructions if you ask them to do something harmful</li></ul><p>The scientists say we need to keep improving how we teach robots, maybe by letting people give even better feedback, or by making robots refuse to do things that are not safe.</p><h3>Why Does This Matter?</h3><p>Robots that can really listen and help us are super useful! They can help with homework, write stories, answer questions, and much more. But we have to make sure they are safe, honest, and don’t hurt anyone. That’s why teaching robots with human feedback is so important.</p><p><strong>Imagine:</strong> If you had a robot friend who always did what you wanted, but also made sure not to say or do anything mean or dangerous. That’s the dream!</p><h3>Conclusion: Teaching Robots, the Human Way</h3><p>The big idea from this research is simple: <strong>Robots learn best when people show them what to do and give them feedback</strong>. Just like you learn from your teachers, parents, or friends, robots can learn from us. And maybe, one day, they’ll be the best helpers ever (and maybe even make a good croissant, who knows?).</p><p><em>Merci for reading! If you have questions, ask your robot friend-maybe it’s already learned to listen.</em></p><h3>Further Reading</h3><ul><li><a href="https://arxiv.org/abs/2203.02155">Original Paper: Training language models to follow instructions with human feedback</a></li><li><a href="https://openai.com/research">OpenAI Research Blog</a></li><li><a href="https://en.wikipedia.org/wiki/Reinforcement_learning">What is Reinforcement Learning?</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=05428d9a5827" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How AlphaCode Learned to Solve Coding Puzzles Like a Real Programmer]]></title>
            <link>https://medium.com/@gtnjuvin/how-alphacode-learned-to-solve-coding-puzzles-like-a-real-programmer-6740cb0f362a?source=rss-66b78b596732------2</link>
            <guid isPermaLink="false">https://medium.com/p/6740cb0f362a</guid>
            <dc:creator><![CDATA[Gaetan Juvin]]></dc:creator>
            <pubDate>Fri, 18 Feb 2022 00:00:50 GMT</pubDate>
            <atom:updated>2025-09-13T19:00:37.643Z</atom:updated>
            <content:encoded><![CDATA[<h3>Introduction: The Magic of Teaching Computers to Code</h3><p>Imagine you are in a big room with thousands of kids, and everyone is trying to solve tricky puzzles as fast as possible. This is called a <strong>coding competition</strong>. Now, what if I tell you a computer can join this contest and do almost as well as a real person? Sounds like science fiction, non? But it is true! Let me tell you the story of <strong>AlphaCode</strong>, a super-smart computer program made by DeepMind, that learned to solve coding puzzles just like us.</p><h3>What is Competitive Programming?</h3><p>Competitive programming is like a sport, but instead of running or jumping, you solve problems using code. You get a problem (like, “How do I sort these numbers super fast?”), and you have to write a program that gives the right answer for every possible test. The best coders are fast, clever, and know many tricks!</p><p><strong>Fun Fact:</strong> Some competitions have more than 5,000 people playing at the same time!</p><h3>Why is Coding Hard for Computers?</h3><p>For us, reading a story and figuring out what to do is (sometimes) easy. But for computers, it is very hard! They need to understand the problem, invent a plan (an algorithm), and write code that works for every case-even the weird ones. If you make a tiny mistake, the code can break. Oops!</p><h3>Meet AlphaCode: The AI Coder</h3><p>AlphaCode is a special kind of computer brain called an <strong>AI model</strong>. It was trained to read problems and write code, just like a human. But how did it learn?</p><h3>How AlphaCode Learns</h3><ul><li>First, it read a <strong>huge amount of code</strong> from the internet (like from GitHub).</li><li>Then, it practiced on real competition problems, learning from both good and bad solutions.</li><li>It learned to understand the words in the problem, and to write code in languages like Python and C++.</li></ul><h3>How AlphaCode Solves Problems</h3><ol><li>It reads the problem, just like you do.</li><li>It tries to write many different programs that might solve the problem (sometimes millions!).</li><li>It tests these programs on example cases to see which ones work.</li><li>It picks the best ones and submits them, hoping to get the right answer!</li></ol><p><strong>Geeky Detail:</strong> AlphaCode uses something called a “transformer” model, which is like a super-powered autocomplete for code, but much smarter.</p><h3>How Good is AlphaCode? (With Fun Examples!)</h3><p>AlphaCode was tested in real competitions on a website called Codeforces. In these contests, it ranked in the <strong>top 54%</strong> of all participants. That means it beat almost half the human coders! For some problems, it even wrote code that was as good as the best humans.</p><p><strong>Example:</strong> There was a problem called “Backspace” where you have to figure out if you can turn one word into another by pressing the backspace key at the right times. AlphaCode read the problem, understood the rules, and wrote a working solution-just like a real competitor!</p><h3>What Makes AlphaCode Special?</h3><ul><li><strong>It doesn’t just copy code.</strong> AlphaCode invents new solutions by understanding the problem, not by cheating.</li><li><strong>It learns from mistakes.</strong> If a program doesn’t work, it tries something different next time.</li><li><strong>It can write code in different languages.</strong> Python, C++, Java-you name it!</li><li><strong>It is careful with tricky cases.</strong> It tests its code on many examples to avoid silly errors.</li></ul><h3>Can AlphaCode Cheat? (Spoiler: No!)</h3><p>Some people worry that AI just memorizes answers. But AlphaCode was tested on problems it had never seen before, and the people who made it made sure it couldn’t just copy from its training. It had to really “think” and solve new puzzles.</p><h3>Why Does This Matter? (And Is It Dangerous?)</h3><p>AlphaCode shows that computers can now solve hard problems that used to be only for humans. This could help make programming easier for everyone, or help us find bugs in our code. But, like all powerful tools, we have to be careful. If people use AI to cheat in contests or write bad code, that is not good! Also, training these big models uses a lot of electricity, so we must think about the planet too.</p><h3>Conclusion: The Future of AI Coders</h3><p>AlphaCode is not perfect-it still makes mistakes, and it is not as good as the very best human coders (yet!). But it is a big step forward. Maybe one day, you will have an AI teammate helping you solve puzzles, or even teaching you new tricks. For now, keep practicing your coding, and maybe you will beat AlphaCode in a contest!</p><p><em>Merci for reading! If you have questions, ask your favorite engineer (or your AI assistant!).</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6740cb0f362a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How AlphaFold Learned to Solve the Protein Puzzle]]></title>
            <link>https://medium.com/@gtnjuvin/how-alphafold-learned-to-solve-the-protein-puzzle-3314aa8c1531?source=rss-66b78b596732------2</link>
            <guid isPermaLink="false">https://medium.com/p/3314aa8c1531</guid>
            <dc:creator><![CDATA[Gaetan Juvin]]></dc:creator>
            <pubDate>Sat, 25 Sep 2021 00:00:30 GMT</pubDate>
            <atom:updated>2025-09-13T19:04:04.376Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>Meta:</strong> Discover how AlphaFold, a smart computer program, learned to predict the shapes of proteins-one of biology’s biggest mysteries-using ideas from both nature and computers.</p><h3>Introduction: The Big Protein Puzzle</h3><p>Imagine you have a super long string of beads, and each bead is a different color. If you drop this string on the floor, it twists and folds into a unique shape. Now, imagine if you could look at the colors and <em>know</em> exactly what shape the string will make. This is the protein puzzle!</p><p>Proteins are tiny machines inside every living thing. They start as long chains of building blocks called amino acids, but to do their jobs, they must fold into special 3D shapes. For more than 50 years, scientists have tried to figure out how to predict these shapes just from the list of building blocks. It’s like trying to guess the shape of a paper airplane just by looking at the instructions-without folding it!</p><h3>Why Do We Care About Protein Shapes?</h3><p>Proteins are everywhere: in your muscles, your hair, even in the food you eat! Their shapes decide what they can do. If a protein folds the wrong way, it might not work, and that can cause diseases. If we know the shape, we can understand how life works, make new medicines, and even design new proteins to help us.</p><h3>The Old Ways: Slow and Tricky</h3><p>Before computers got clever, scientists had to use special machines to <strong>see</strong> protein shapes. This could take months or even years for just one protein! Imagine waiting that long for your favorite video game to load-no, merci!</p><p><strong>Fun Fact:</strong> Out of billions of known protein sequences, only about 100,000 shapes have been figured out the old way. That’s like knowing the shape of just a few LEGO sets out of a whole toy store!</p><h3>The New Hero: AlphaFold</h3><h4>What is AlphaFold?</h4><p>AlphaFold is a super-smart computer program made by scientists at DeepMind. It’s like a detective that looks at the list of amino acids and predicts how the protein will fold-almost as if it can see the future!</p><h4>How Does AlphaFold Work?</h4><p>AlphaFold uses something called <strong>deep learning</strong>. This is a way for computers to learn from lots and lots of examples, kind of like how you learn to ride a bike by practicing. AlphaFold looked at thousands of known protein shapes and learned the secret rules of folding.</p><p>But AlphaFold is not just copying. It can predict shapes for proteins that no one has ever seen before, and it does this with amazing accuracy-sometimes as good as the real experiments!</p><h3>The Secret Sauce: Learning from Nature and Computers</h3><h4>Evolution and Physics</h4><p>AlphaFold is clever because it uses two big ideas:</p><ul><li><strong>Evolution:</strong> Proteins that are similar often fold in similar ways. AlphaFold looks at families of proteins from many living things to spot patterns.</li><li><strong>Physics:</strong> It also knows some rules about how atoms like to stick together, so it doesn’t make impossible shapes.</li></ul><h4>The Magic of Deep Learning</h4><p>Inside AlphaFold is a special kind of computer brain called a <strong>neural network</strong>. It’s made of many layers, each learning a different part of the folding puzzle. AlphaFold’s network is called <em>Evoformer</em> (sounds like a superhero, eh?), and it passes information back and forth, getting better and better at guessing the shape.</p><p><strong>Geeky Bit:</strong> AlphaFold can even tell you how confident it is about each part of its prediction. If it’s not sure, it says so!</p><h3>How Good is AlphaFold?</h3><p>In a big worldwide test called CASP (Critical Assessment of protein Structure Prediction), AlphaFold was the best-by a lot! It could predict the shape of proteins with an accuracy almost as good as the real thing. For most proteins, the difference between AlphaFold’s guess and the real shape is smaller than the width of a single atom. C’est incroyable!</p><p>“The width of a carbon atom is about 1.4 angstroms. AlphaFold’s predictions are often within 1 angstrom of the real thing!”</p><h3>Why Does This Matter?</h3><p>With AlphaFold, scientists can now predict the shapes of proteins in hours instead of years. This helps us:</p><ul><li>Understand how diseases work</li><li>Design new medicines</li><li>Make better crops and foods</li><li>Explore the mysteries of life, from tiny bacteria to giant whales!</li></ul><h3>What’s Next for AlphaFold and Science?</h3><p>AlphaFold is just the beginning. Its ideas can help solve other big puzzles in biology and chemistry. Maybe one day, we’ll use computers to design new proteins that can clean up pollution, cure diseases, or even build new materials.</p><p><strong>Did you know?</strong> The AlphaFold team made their code and data open for everyone. Now, scientists all over the world can use it for free!</p><h3>Conclusion: The Future is Bright (and a bit geeky)</h3><p>AlphaFold shows us what happens when we mix clever ideas from nature, physics, and computer science. It’s like a big team of scientists and computers working together. And who knows? Maybe one day, you’ll use AlphaFold to make your own discoveries!</p><p><em>Merci for reading, and remember: even the biggest puzzles can be solved, one piece at a time!</em></p><p>Based on: Jumper, J. et al. “Highly accurate protein structure prediction with AlphaFold.” Nature 596, 583–589 (2021). <a href="https://doi.org/10.1038/s41586-021-03819-2">Read the original paper</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3314aa8c1531" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How Codex Learns to Code: Explaining Large Language Models]]></title>
            <link>https://medium.com/@gtnjuvin/how-codex-learns-to-code-explaining-large-language-models-2d6fb7a1e1b7?source=rss-66b78b596732------2</link>
            <guid isPermaLink="false">https://medium.com/p/2d6fb7a1e1b7</guid>
            <dc:creator><![CDATA[Gaetan Juvin]]></dc:creator>
            <pubDate>Fri, 24 Sep 2021 00:00:35 GMT</pubDate>
            <atom:updated>2025-09-13T19:22:53.521Z</atom:updated>
            <content:encoded><![CDATA[<p>Imagine if your computer could write code for you, just by reading what you want in plain English. Sounds like magic, right? Well, that’s what Codex, a super-smart AI, is trying to do! In this blog, I’ll explain how Codex works, how scientists test it, and what it means for the future of programming-all in a way that even a ten-year-old can understand (and maybe a few grown-ups too).</p><h3>What is Codex? (And Why Should You Care?)</h3><p>Codex is a special kind of computer brain called a <strong>large language model</strong>. It’s like a robot that has read millions of lines of code from the internet (especially from GitHub) and learned how to write its own code. If you tell Codex, “Write a function that adds two numbers,” it can do it! In fact, Codex is the brain behind GitHub Copilot, the tool that helps programmers by suggesting code as they type.</p><p><strong>Example:</strong> If you write a comment like # make a function that checks if a number is prime, Codex can write the Python code for you!</p><h3>How Do You Teach a Computer to Code?</h3><h4>Step 1: Feed It Lots of Code</h4><p>Codex learned by reading <strong>159 gigabytes</strong> of Python code from 54 million public GitHub projects. That’s more code than most humans will see in their whole life! It also learned from natural language, so it understands both code and English.</p><h4>Step 2: Practice Makes Perfect</h4><p>The scientists gave Codex lots of practice problems, like little puzzles. For example, “Write a function that returns the longest word in a list.” Codex tries to solve these, and if it gets it wrong, it learns from its mistakes.</p><h4>Step 3: Test, Test, Test!</h4><p>To see how good Codex is, the researchers made a special test called <strong>HumanEval</strong>. It’s a set of 164 hand-written programming problems, each with its own tests (like mini-exams for code). Codex has to write code that passes all the tests.</p><h3>How Do We Know If Codex Is Good?</h3><h4>Functional Correctness: Does It Work?</h4><p>The most important question: <strong>Does the code actually do what it’s supposed to?</strong> To check this, Codex’s code is run through <strong>unit tests</strong> -little programs that check if the answer is right.</p><p><strong>Example:</strong> If the problem is “add two numbers,” the test might check if add(2, 3) gives 5.</p><h4>Pass@k: How Many Tries Does It Take?</h4><p>Sometimes Codex gets it right on the first try, sometimes it needs a few attempts. Scientists use a metric called <strong>pass@k</strong>: if you let Codex try <em>k</em> times, what’s the chance it gets at least one correct answer?</p><p><strong>Example:</strong> If Codex solves 70 out of 100 problems in 100 tries each, its pass@100 is 70%.</p><h4>Better Than BLEU</h4><p>Some old tests just checked if Codex’s code looked like the “official” answer (using something called BLEU score). But in code, there are many ways to solve a problem! So, passing the tests is more important than looking the same.</p><h3>How Well Does Codex Do?</h3><ul><li>With just one try, Codex solves about <strong>29%</strong> of HumanEval problems.</li><li>If you let it try 100 times and pick the best, it solves over <strong>70%</strong>!</li><li>Older models like GPT-3 solve almost none, and GPT-J solves about 11%.</li></ul><p><strong>Geeky fact:</strong> The more code Codex reads and the bigger its “brain” (number of parameters), the better it gets-just like a human who practices a lot!</p><h3>What Are Codex’s Weaknesses?</h3><ul><li><strong>Long Instructions:</strong> If you give Codex a really long, complicated problem, it gets confused (like a kid who forgets the start of a long story).</li><li><strong>Binding Variables:</strong> Sometimes it mixes up which variable does what, especially if there are many steps.</li><li><strong>Not Always Safe:</strong> Codex can write code that is insecure or buggy, especially if the instructions are unclear or have mistakes.</li><li><strong>Bias:</strong> Because it learned from public code, it can pick up bad habits or even biased ideas.</li></ul><h3>How Do Scientists Make Codex Better?</h3><h4>Supervised Fine-Tuning</h4><p>The researchers gave Codex extra lessons using problems from coding competitions and open-source projects with good tests. This made a new version called <strong>Codex-S</strong>, which is even better at solving problems.</p><h4>Docstring Generation</h4><p>Codex can also learn to write <strong>docstrings</strong> (the little text that explains what a function does). This helps make code easier to understand and safer to use.</p><h3>Why Does This Matter? (The Big Picture)</h3><ul><li><strong>Helps Programmers:</strong> Codex can save time, help beginners, and make coding more fun.</li><li><strong>Needs Supervision:</strong> You still need a human to check the code-Codex is smart, but not perfect!</li><li><strong>Safety and Security:</strong> We must be careful, because Codex can make mistakes or suggest unsafe code.</li><li><strong>Fairness:</strong> Codex can accidentally repeat biases from its training data, so we need to watch out for that.</li><li><strong>Environmental Impact:</strong> Training big models uses a lot of electricity, so it’s important to use green energy when possible.</li></ul><h3>What’s Next for Codex and AI Coding?</h3><p>Codex is already helping programmers around the world, but there’s still lots to improve. Scientists are working on making it safer, more reliable, and better at understanding what people really want. Maybe one day, anyone-even a ten-year-old-can build their own apps just by describing them!</p><p><strong>Fun challenge:</strong> Try giving Codex a weird or tricky problem and see what it does. But always check its answers-sometimes it’s a bit like a clever but mischievous classmate!</p><h3>Summary: What Did We Learn?</h3><ul><li>Codex is a super-smart AI that learned to code by reading lots of code and English.</li><li>It’s tested by making it solve real problems and checking if its code works.</li><li>It’s not perfect-sometimes it makes mistakes, so humans still need to check its work.</li><li>Codex is already changing how people write code, but we need to use it wisely and safely.</li></ul><p>Merci for reading! If you have questions or want to try Codex yourself, ask your favorite grown-up programmer-or maybe, one day, you’ll teach Codex a thing or two!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2d6fb7a1e1b7" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>