<?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[42 Studio - Medium]]></title>
        <description><![CDATA[Stories of building and learning. - Medium]]></description>
        <link>https://medium.com/a-42-journey?source=rss----89676ea48d2a---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>42 Studio - Medium</title>
            <link>https://medium.com/a-42-journey?source=rss----89676ea48d2a---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 16:22:20 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/a-42-journey" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Your next AI skill is worldbuilding]]></title>
            <link>https://medium.com/a-42-journey/your-next-ai-skill-is-worldbuilding-927d573038ef?source=rss----89676ea48d2a---4</link>
            <guid isPermaLink="false">https://medium.com/p/927d573038ef</guid>
            <category><![CDATA[prompt-engineering]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[future-of-work]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Jean-Baptiste Terrazzoni]]></dc:creator>
            <pubDate>Sat, 23 May 2026 21:32:58 GMT</pubDate>
            <atom:updated>2026-05-23T21:32:58.003Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*FiPC8h54Kj_eiXmS" /></figure><p>Last month, four people told me they were “using agents.”</p><p>They meant four different things.</p><p>One meant ChatGPT in a browser tab. One meant a Python script calling the OpenAI API. One meant an agent in a workspace, reading docs, editing files, and updating a launch plan. One meant an agent on a remote machine, working through tickets while they slept.</p><p>Same word. Completely different systems.</p><p>This is why the conversation around AI agents feels blurry. We argue about which model is best, GPT or Claude, Gemini or Grok, this week’s benchmark over last week’s. The model matters. It is not the center.</p><p>What matters more, in 2026, is what you build <em>around</em> the model: context it can read, tools it can use, memory it can keep, rules for what good looks like, and feedback that teaches it when it was wrong. Markdown files. Product notes. Customer history. A few tools. Permissions.</p><p><strong>The hard part is no longer buying a brain. It is giving that brain a world.</strong></p><h3>Levels of independence</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*9V5NbIFPkiHdwH7g" /></figure><p>The four people from the opening sit on one spectrum: <strong>how much freedom the AI has to decide what happens next.</strong></p><p><strong>1. The chatbot:</strong> answer only. ChatGPT, Claude.ai, Gemini in a browser tab. You ask. It answers. You decide what the answer means. No tools, no durable memory, no action, intelligence on tap, but every step still passes through your hands.</p><p><strong>2. The programmatic call: </strong>reasoning inside your product. Your product calls a model. Inputs go in, text or structured data comes back, and your code decides the next step. The AI reasons inside a box you built.</p><p><strong>3. The supervised agent:</strong> independent steps, visible loop. Claude Code, Codex, Cursor’s agent mode, or any workspace agent with tools. It reads files, runs commands, edits documents, checks results, and decides what to try next. You are still there. You can interrupt. But it is no longer just answering, it is moving through the work.</p><p><strong>4. The autonomous agent: </strong>delegated execution. The human steps further out. An agent on a remote machine clicks through a browser, processes tickets, runs steps, and hands back work for review. You set the goal. It picks the path.</p><p>The thing that wraps the model and runs this loop is the <strong>harness</strong>. Claude Code, Cursor, Codex, Operator: all harnesses. The harness gives a model tools, memory, permissions, and a loop. Same model, different harness, different creature.</p><p>These levels are not a ranking. A chatbot is not worse than an autonomous agent; it is a different shape. Most failures come from choosing the wrong one, full autonomy for a problem that needed a conversation, a chatbot for work that needed a worker. <strong>The model is not always the issue. The amount of independence is.</strong></p><h3>From models to worlds</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Zen5CVCnPPyT_4pA" /></figure><p>Two years ago, picking the model was the conversation. Today, you pay OpenAI, Anthropic, or Google and get a very good brain. What you do around that brain is the game.</p><p>Think of the model as a mind plus an education. It comes loaded with language, reasoning, patterns, and taste from the world it was trained on. You cannot really change it. You rent it. Now think of architecture <strong>as the workshop you put that mind into.</strong></p><p>A brilliant person in an empty room can give advice. The same person with customer notes, dashboards, documents, colleagues, and feedback can run part of a business. Same mind, different world, different output.</p><p>We know this about humans. A strong operator dropped into chaos underperforms; a less experienced person inside a clear team, with good tools and tight feedback, suddenly looks excellent. AI works the same way.</p><p>The people building serious AI systems in 2026 are not just benchmark-watchers. They design what the agent reads, what it can touch, what it remembers, what it refuses, and what counts as good work.</p><p><strong>The model is the seed. The world is the soil.</strong></p><h3>The world stack</h3><p>Every useful AI system is some mix of identity, tools, skills, and knowledge. Together, they are the world the model wakes up inside.</p><h3>Identity: Who is this thing?</h3><p>The system prompt is not just instructions. It is identity, who the agent is, what it cares about, what it ignores, what it refuses to do.</p><p>Inside a harness, prompts split into two layers. The <strong>system prompt</strong> is the standing order, often extended by files like CLAUDE.md, AGENTS.md, or whatever your tool reads on startup. The <strong>user prompt</strong> is today&#39;s task. Most leverage lives in the standing order, because it shapes every decision after it.</p><p>A common mistake is trying to build Jarvis: one universal assistant that does everything. That is usually the wrong shape. Build agents like you hire people, one purpose each, a support triage agent that does nothing else, a growth analyst watching the funnel, a research agent that reads, summarizes, and shuts up.</p><p><strong>The magic is not one giant assistant. It is the coordination between focused minds.</strong></p><h3>Tools: The body</h3><p>A model with no tools is a brilliant hire with no hands. It can think, but it cannot act. Tools give the agent a body: read files, query a dashboard, update a spreadsheet, search the web, create a ticket, send a draft, click a browser, change a document.</p><p>Two main flavors today. <strong>CLIs</strong> let the agent work the way a developer does, typing commands to open files, query a database, run a script. Flexible, brutal, immediate. <strong>MCPs</strong> are pre-built connectors to specific apps, your CRM, calendar, docs, each with clear rules about what it accepts and returns. Structured, discoverable, shared. CLI gives the agent a body that can improvise; MCP gives it contracts it can trust. Permissions decide how far that body is allowed to move.</p><p>Without tools, your agent can describe what should happen. With tools, it can make something happen. That gap is the industry.</p><h3>Skills: Modular memory</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*MVZbIK-mV_Om4PUg" /></figure><p>Skills are small instructions the agent loads when relevant.</p><p><em>“How we write customer updates here.”</em> <em>“How to qualify a lead.”</em> <em>“How to prepare the weekly metric brief.”</em></p><p>They are not personality, they are procedure. The model does not remember what you taught it yesterday; every session starts fresh. Skills are the inspectable modules you leave on disk so the right one gets reloaded at the right moment.</p><p>Why not put everything in the system prompt? Because dumping everything into every call creates noise, and the agent loses focus. Skills load just-in-time, so working memory stays clean.</p><p>Here is what one looks like:</p><pre>---<br>name: weekly-metric-brief<br>description: Standard weekly business update format<br>---<br><br>Start with the three numbers that changed.<br>Explain why they moved, not only what moved.<br>Separate facts from interpretation.<br>End with the decision needed this week.</pre><p>A few lines of plain text. The whole system is markdown plus one routing decision: <em>when does the agent need this?</em></p><p>The next step is obvious: the agent writes its own. Let it review a session, <em>what did I learn? What should next-me remember?</em>, keep the good ones, drop the rest, and the pile grows on its own. Manual now, automated soon.</p><h3>Knowledge: The long memory</h3><p>The model’s training is frozen the day it shipped. Your reality is not. Knowledge bases are how you give an agent context the model could not have known: product strategy, customer history, pricing logic, past decisions, team vocabulary, political landmines, taste.</p><p>This is where your world becomes legible. Not the whole world, the useful part: the scars, constraints, customer details, and decisions that otherwise stay trapped in your head until the agent guesses wrong.</p><h3>Context is the world entering the model</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*rohurSC8xj09lgSc" /></figure><p>The model arrives at your project like a world-class consultant on day one. Brilliant, fast, trained on everything, and with no idea who you are, what you shipped last month, which customer yelled at you, what your team promised never to do again, or which tiny detail makes the whole system fragile.</p><p>Every gap becomes a guess. And models guess beautifully. That is the danger, not that they are stupid, but that they are smart enough to make the wrong world feel coherent.</p><p>The fix is <strong>context maxing</strong>. Not stuffing the window with more tokens, but compressing your world into words dense enough that the model reconstructs the right one.</p><p>Language is already compression. Every word is a pointer that expands inside the reader’s head. When you write to a model, you decide which parts of your world it gets to reconstruct. <strong>Sloppy prose unpacks into a sloppy world. Tight prose unpacks into yours.</strong></p><p>Good context carries three things:</p><p><strong>Emotion</strong>, what is at stake, what you care about, what you would hate to ship wrong. <em>“This goes to a paying customer tomorrow”</em> produces different work than <em>“please write this.”</em></p><p><strong>Complexity</strong>, the constraints and edge cases you already lived. <em>“We tried X, it failed under load, we settled on Y”</em> gives the model a real map.</p><p><strong>Reality</strong>, names, numbers, specifics. <em>“Marie, running a 3-person agency on Squarespace”</em> beats <em>“a small business owner.”</em> Concrete details kill wrong assumptions before they start.</p><p>This is why the people whose agents work best are often the people who already write well, founders who can pitch, operators who can brief, designers who can explain. They have already trained the skill of packing reality into language.</p><p>The most important AI skill in 2026 is not prompt tricks. It is writing clearly enough that another intelligence can act inside your world without inventing a fake one.</p><h3>What changes when you build the world</h3><p>Once you see the world around the model, a few things become obvious.</p><p><strong>Benchmarks stop being the main question.</strong> A weaker model inside a rich world can beat a stronger model inside an empty room. Not always. Often enough that model rankings alone become a bad buying guide.</p><p><strong>The world does not replace the mind. </strong>The best models still generalize better. They hold more context, recover from ambiguity faster, connect distant ideas, and fail less stupidly on hard tasks. Cheap models are fine for cheap work; hard reasoning is still pay-to-win.</p><p><strong>Use models like people. </strong>Route strategy, research, analysis, critique, and execution to different models the way a company routes work to different specialists.</p><p><strong>Evaluation becomes central.</strong> If the agent can act, you need to know when it acted well. Vibes are not enough, build examples, score outputs, track regressions. The eval set is the floor under the system.</p><p><strong>The human skill stack changes.</strong> Writing clear briefs, sharing context, breaking work into small tasks, reviewing output hard, knowing what good looks like, shipping without letting speed become slop. These used to be soft skills. Now they are load-bearing.</p><p><strong>AI multiplies what is already there.</strong> A strong founder with agents ships a sharper company faster. A confused operator with agents creates confusion faster. The agent did not make one brilliant and the other careless, it revealed the difference. <strong>What you feed the system is what the system scales.</strong></p><h3>Build a team, not a tool</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*gkGnU8kISuiqfMeI" /></figure><p>Your AI should feel like a team, not a tool. A tool waits for your hand; a team carries part of the work. Each agent has a role, memory, tools, and standards, and together they become leverage around you.</p><p>The model is the raw intelligence. You do not build the intelligence, you build the team around it. Do not memorize the stack either. The specifics will keep moving. Understand the shape: a brain, a harness, a world, a loop. That shape is durable.</p><p>That is what 2026 feels like from the workbench. Not picking models, not chasing benchmarks, not waiting for AGI. Writing markdown, shaping environments, wiring tools, curating knowledge, turning your taste into a system something else can execute.</p><p>You are not configuring a chatbot anymore. You are designing a small operating system for intelligence.</p><p><strong>Stop asking only which model. Start asking what world.</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=927d573038ef" width="1" height="1" alt=""><hr><p><a href="https://medium.com/a-42-journey/your-next-ai-skill-is-worldbuilding-927d573038ef">Your next AI skill is worldbuilding</a> was originally published in <a href="https://medium.com/a-42-journey">42 Studio</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What if we got online shopping wrong?]]></title>
            <link>https://medium.com/a-42-journey/connecting-shops-to-customers-directly-4d5e83c8f274?source=rss----89676ea48d2a---4</link>
            <guid isPermaLink="false">https://medium.com/p/4d5e83c8f274</guid>
            <category><![CDATA[shop]]></category>
            <category><![CDATA[ethereum]]></category>
            <category><![CDATA[shopping]]></category>
            <category><![CDATA[smart-contracts]]></category>
            <category><![CDATA[application]]></category>
            <dc:creator><![CDATA[Jean-Baptiste Terrazzoni]]></dc:creator>
            <pubDate>Sun, 07 Sep 2025 13:33:09 GMT</pubDate>
            <atom:updated>2025-11-29T00:54:49.301Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VMrs7wCWL8RsFW6pkVv82Q.png" /></figure><p>We love the convenience of modern e-commerce. Two taps, and a package arrives the next day. It feels like magic.</p><p>However, there is a hidden cost to this efficiency. We have largely traded the diversity of local markets for centralized platforms. In doing so, the economy has consolidated around a few massive giants. When a single algorithm determines what millions of people see and buy, the market becomes fragile.</p><h3>The Problem: Commerce is Stuck in the “TV Station” Era</h3><p>To understand the issue, look at how the internet transformed media.</p><ul><li><strong>Before:</strong> A few major TV stations and newspapers controlled the narrative (Centralized).</li><li><strong>After:</strong> Blogs, YouTube, and social media allowed anyone to broadcast to the world (Decentralized).</li></ul><p>Media became democratic. <strong>Commerce did not.</strong></p><p>Today, merchants face a binary choice:</p><ol><li><strong>The Lonely Island:</strong> Build your own website and struggle to get anyone to visit.</li><li><strong>The Walled Garden:</strong> Rent space from a giant platform (like Amazon) that controls the rules, takes a significant cut (often 30%+), and hides your customer data.</li></ol><p>The question is: <strong>Why can’t we democratize trade the way we democratized publishing?</strong></p><h3>The Solution: A Protocol, Not a Platform</h3><p>The answer lies in shifting our thinking from “platforms” to “protocols.”</p><p>A <strong>platform</strong> is a private company (like a shopping mall owner) that owns the building and sets the rent. A <strong>protocol</strong> is a public standard (like email or the web itself) that anyone can use.</p><p>Imagine an ecosystem that functions as a <strong>public utility for commerce</strong>:</p><ol><li><strong>Permissionless Access:</strong> Just like anyone can send an email without asking Google for permission, any merchant should be able to list products without a gatekeeper.</li><li><strong>Direct Connection:</strong> The transaction happens directly between buyer and seller. The protocol connects them, but it doesn’t stand in the middle.</li><li><strong>Neutral Infrastructure:</strong> The system provides the plumbing (listings, payments, reputation) but doesn’t compete with the merchants. It won’t analyze sales data to launch a copycat product.</li></ol><p>This creates a digital town square where a global brand and a local artisan stand on equal footing, distinguished only by their reputation and product quality.</p><h3>Innovation at the Edges</h3><p>This isn’t just philosophy; it’s a technical opportunity.</p><p>Currently, innovation in shopping is bottlenecked by a few large companies. If you want a better search engine or a faster delivery network, you have to wait for the giants to build it.</p><p>By moving to a <strong>decentralized protocol</strong>, we unlock “innovation at the edges.” Since the data is open and standardized, independent developers can build on top of it:</p><ul><li><strong>Specialized Interfaces:</strong> A developer could build a boutique app just for vintage cameras that pulls from the global inventory but offers specific filtering tools the giants ignore.</li><li><strong>Hyper-local Logistics:</strong> A local courier service could plug into the protocol to offer eco-friendly delivery in just one city, without needing a global partnership.</li><li><strong>Community Curation:</strong> Instead of ads driving discovery, communities could build their own curated feeds of trusted products.</li></ul><h3>Bringing the Human Back</h3><p>The goal isn’t technology for technology’s sake. It’s about restoring balance to the economy.</p><p>A protocol-based approach aims for a future where online shopping retains its convenience but supports a diverse ecosystem of creators and shop owners.</p><ul><li><strong>Level playing field:</strong> Small players access the same tools as large ones.</li><li><strong>Real connection:</strong> Commerce becomes social and relational again.</li><li><strong>Open source:</strong> No black boxes or hidden algorithms.</li></ul><p>It is a complex challenge, but the future of shopping doesn’t have to be limited to a single “buy” button owned by a giant.</p><p>Let’s build something better. 🚀</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4d5e83c8f274" width="1" height="1" alt=""><hr><p><a href="https://medium.com/a-42-journey/connecting-shops-to-customers-directly-4d5e83c8f274">What if we got online shopping wrong?</a> was originally published in <a href="https://medium.com/a-42-journey">42 Studio</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[When AI becomes the product]]></title>
            <link>https://medium.com/a-42-journey/ai-in-development-programming-intelligence-itself-2228883a67eb?source=rss----89676ea48d2a---4</link>
            <guid isPermaLink="false">https://medium.com/p/2228883a67eb</guid>
            <category><![CDATA[ai-programming]]></category>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[productivity]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Jean-Baptiste Terrazzoni]]></dc:creator>
            <pubDate>Fri, 25 Jul 2025 21:48:19 GMT</pubDate>
            <atom:updated>2026-01-07T23:18:04.325Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*F3Gy2Xg3jXjSfQcs" /></figure><p>There is a moment when AI stops being your assistant and starts being your architecture.</p><p>For me, it happened while building a news aggregation API. The feature seemed straightforward: deduplicate incoming articles. Compare titles, check keyword overlap. Standard engineering.</p><p>Then I hit the wall. Is <em>“Fed raises rates”</em> the same story as <em>“Federal Reserve increases interest rates amid inflation concerns”</em>? What about <em>“Powell signals hawkish monetary stance”</em>?</p><p>The headlines share almost no words, yet they describe the same underlying reality. No amount of string matching solves this. The problem requires <em>understanding</em>.</p><p>That was when the architecture changed. AI wasn’t helping me build the feature anymore. AI was the feature.</p><p>This shift, from AI as a tool to AI as a component, requires a different way of thinking. Traditional engineering intuitions break down. New patterns emerge.</p><h3>The trap of pure approaches</h3><p>Most developers fall into one of two traps when integrating AI:</p><ol><li>The Magic Trap: Treat AI as a black box that solves everything. Pipe in data, get answers. This works until the model hallucinates or returns unparseable JSON.</li><li>The Fear Trap: Treat AI as too unreliable to trust. Wrap it in so many layers that it rarely executes.</li></ol><p>Both traps stem from treating AI as absolute. The reality is nuanced. AI is reliably good at some things (semantic understanding, fuzzy classification) and unreliably bad at others (precision, math, strict adherence to rules).</p><h3>The hybrid principle</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*noQkS3TU2QyulT28" /></figure><p>The solution is Hybrid Architecture: code for constraints, AI for reasoning.</p><ul><li>Code is deterministic, verifiable, fast, and precise.</li><li>AI is flexible, semantic, creative, and fuzzy.</li></ul><p>The division of labor becomes clear:</p><ul><li>Give to Code: Data fetching, schema validation, business rules, state management.</li><li>Give to AI: Semantic understanding, fuzzy classification, content generation, summarization.</li></ul><p>Code protects invariants. AI handles ambiguity.</p><h3>The sandwich pattern</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*tufiROie9G_wllYR" /></figure><p>Every AI call in my system follows the same structure: Code → AI → Code.</p><p>I call it the Sandwich Pattern. Code prepares the input, AI reasons over it, code validates the output. The AI’s flexibility is contained entirely within code’s constraints.</p><h3>Layer 1: Preparation (code)</h3><p>Before the AI sees anything, code runs:</p><pre>const existingReports = await this.reportRepository.findRecent({<br>    country: newReport.country,<br>    limit: 50,<br>});<br><br>const formattedReports = existingReports.map(r =&gt; ({<br>    id: r.id,<br>    core: r.core.value,<br>    background: r.background.value,<br>}));<br><br>const prompt = buildDeduplicationPrompt(newReport, formattedReports);</pre><p>Code controls what data the AI sees, how much, and in what format. The AI receives a curated view.</p><h3>Layer 2: Reasoning (AI)</h3><p>The AI receives the formatted data and a clear instruction:</p><blockquote>“Determine whether the incoming news report describes the same underlying event as any existing report. Focus on the core event, who did what, when, where.”</blockquote><p>This is the task I cannot hardcode. The AI reasons about semantic equivalence.</p><h3>Layer 3: Validation (code)</h3><p>The AI’s output is constrained by a schema:</p><pre>const DeduplicationResult = z.object({<br>    duplicateOfReportId: z.string().uuid().nullable(),<br>    reason: z.string().max(500),<br>    confidence: z.enum([&#39;high&#39;, &#39;medium&#39;, &#39;low&#39;]),<br>});<br><br>const parsed = DeduplicationResult.safeParse(aiResponse);<br><br>if (!parsed.success) {<br>    logger.warn(&#39;AI returned invalid response&#39;, { error: parsed.error });<br>    return { isDuplicate: false, reason: &#39;Validation failed&#39; };<br>}</pre><p>The AI cannot return “maybe” or invent new states. If validation fails, the system falls back gracefully. The sandwich ensures AI’s flexibility operates strictly within code’s constraints.</p><h3>A real example: The fabrication agent</h3><p>My news app includes a “spot the fake” game. I need an agent to generate convincing fake news.</p><p>Preparation: Code selects a real article for style inspiration and sets the difficulty level.</p><pre>const prompt = buildFabricationPrompt({<br>    inspiration: realArticle,<br>    targetCategory: &#39;technology&#39;,<br>    difficulty: &#39;medium&#39;,<br>});</pre><p>Reasoning: The AI generates the fake article.</p><p>Validation:</p><pre>const FabricatedArticle = z.object({<br>    headline: z.string().min(10).max(100),<br>    body: z.string().min(200).max(2000),<br>    tone: z.enum([&#39;satirical&#39;]),<br>});</pre><p>But schema validation isn’t enough for content safety.</p><pre>const safetyResult = await this.safetyChecker.analyze(article);<br>if (safetyResult.flagged) {<br>    return this.sendToHumanReview(article);<br>}</pre><p>Some content goes to a human review queue. The architecture assumes AI will occasionally produce something problematic and builds in the gate.</p><h3>Testing probabilistic systems</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*0wt_ZQkbk7LhASdx" /></figure><p>Traditional testing assumes determinism: given input X, expect output Y. AI breaks this.</p><p>This requires a three-layer testing strategy:</p><ol><li>Unit Tests for Code: The preparation and validation layers are deterministic. Test them normally.</li><li>Evals for AI: Maintain a dataset of test cases with known correct answers. Run the AI against all of them and measure accuracy. If accuracy drops below a threshold (e.g., 90%), the deploy fails.</li><li>Guardrail Tests: Test what happens when the AI misbehaves.</li></ol><pre>test(&#39;gracefully handles malformed AI response&#39;, async () =&gt; {<br>    mockModel.mockReturnValue({ invalid: &#39;garbage&#39; });<br>    const result = await pipeline.process(newReport);<br>    expect(result.fallbackUsed).toBe(true);<br>});</pre><p>The system must be robust to AI failures, not just AI successes.</p><h3>The orchestrator mindset</h3><p>Building systems with AI components requires a mental shift from writing logic to orchestrating behavior.</p><p>You define constraints and goals. The AI figures out how to achieve them. Your job is ensuring it stays within bounds.</p><p>Principles of the Orchestrator:</p><ol><li>Validate Everything: Never trust AI output.</li><li>Design Fallbacks: Every AI call should have a graceful degradation path.</li><li>Log Extensively: Logs are your only window into the “black box.”</li><li>Expect Drift: AI behavior changes over time. Monitor continuously.</li></ol><p>AI gives you capabilities that were impossible before. Semantic understanding. Fuzzy classification. The tradeoff is unpredictability.</p><p>Good architecture makes that tradeoff worthwhile. You get the capabilities. You contain the unpredictability. Let code do code’s job. Let AI do AI’s job. Design the boundaries with care.</p><p><em>This article is the first in a series exploring each level in depth. Next up: Level 2, how to shift from writing code to directing the agents that write it.</em></p><ol><li><a href="https://medium.com/a-42-journey/four-levels-of-ai-ride-the-wave-and-amplify-your-potential-4952e55f37c3">The four levels of AI integration</a></li><li><a href="https://medium.com/a-42-journey/ai-in-development-from-coder-to-conductor-d236ebc7e2e4">The art of directing AI</a></li><li><a href="https://medium.com/a-42-journey/ai-in-development-the-rise-of-the-autonomous-agent-d512c681d15b">Collaborating with AI on larger problems</a></li><li><a href="https://medium.com/a-42-journey/ai-in-development-programming-intelligence-itself-2228883a67eb"><strong>When AI becomes the product</strong></a></li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2228883a67eb" width="1" height="1" alt=""><hr><p><a href="https://medium.com/a-42-journey/ai-in-development-programming-intelligence-itself-2228883a67eb">When AI becomes the product</a> was originally published in <a href="https://medium.com/a-42-journey">42 Studio</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Collaborating with AI on larger problems]]></title>
            <link>https://medium.com/a-42-journey/ai-in-development-the-rise-of-the-autonomous-agent-d512c681d15b?source=rss----89676ea48d2a---4</link>
            <guid isPermaLink="false">https://medium.com/p/d512c681d15b</guid>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[productivity]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[ai-agent]]></category>
            <dc:creator><![CDATA[Jean-Baptiste Terrazzoni]]></dc:creator>
            <pubDate>Thu, 24 Jul 2025 20:20:26 GMT</pubDate>
            <atom:updated>2026-01-07T23:17:50.133Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*BdZeOHviGNieXQyU" /></figure><p>There is a distinct moment when you realize you aren’t coding anymore. You are watching.</p><p>I gave a single prompt: <em>“Add CSV export to the analytics dashboard. Follow our existing PDF export patterns.”</em> Then I sat back.</p><p>The agent explored my codebase, located the PDF export service, analyzed the pattern, and began to build. Backend route, data transformation layer, frontend component. All from one sentence.</p><p>When it hit an ambiguity, should the export include archived records?, it made a probabilistic choice. I caught it scrolling past and intervened: <em>“No, filter to active records only.”</em> It adjusted and continued.</p><p>Twenty minutes later: a working feature, passing tests, ready for review.</p><p>This isn’t autocomplete. It isn’t even “Directing.” It is something fundamentally different: Collaboration. You set a goal, the AI navigates toward it, and you intervene when the trajectory drifts. It is a conversation toward a solution, powered by models like Claude Opus 4.5 that can hold complex context and reason over multiple steps.</p><h3>What makes collaboration different</h3><p>Most AI-assisted coding is transactional. You ask for X, you get X.</p><p>Collaboration is iterative. The AI explores, decides, and builds. The shift looks like this:</p><ul><li>Autocomplete: You type code. AI predicts tokens.</li><li>Direction: You specify changes. AI executes transformations.</li><li>Collaboration: You set goals. AI explores and builds. You guide.</li></ul><p>In collaboration, you aren’t reviewing every line, you are reviewing direction. Is this heading where I want? Did it make reasonable choices? What did it miss?</p><p>The thinking stays with you. But instead of translating every thought into syntax, you are guiding an entity that builds while you shape.</p><h3>The collaboration loop</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Jpi_hG8ZhKX1w3zy" /></figure><p>Collaboration follows a rhythm. Once you recognize it, you can wield it deliberately.</p><h3>1. Set direction</h3><p>Start with a clear goal and enough context for the AI to make high-quality probabilistic choices.</p><blockquote>“Add user authentication with email/password and OAuth. Follow our existing patterns in the auth folder. Use next-auth, we already have it installed.”</blockquote><p>The more context you provide upfront (specific files, libraries, patterns), the fewer corrections you’ll need later.</p><h3>2. Watch actively</h3><p>Do not walk away. Watch where the AI is heading.</p><p>This is different from reviewing a final diff. You are observing decisions <em>as they are made</em>. Is it looking at the right files? Did it choose the correct pattern? Is it about to go down a path you will need to undo?</p><p>Active watching lets you intervene <em>before</em> the AI builds on a flawed foundation.</p><h3>3. Intervene precisely</h3><p>When you see a deviation, be specific.</p><blockquote>“Stop, that’s the wrong library. We use jose for JWT handling, not jsonwebtoken. Check auth/utils.ts.&quot;</blockquote><p>Good interventions are surgical. You aren’t restarting; you are course-correcting.</p><h3>4. Refine progressively</h3><p>As the feature takes shape, you shift from structural guidance to polish.</p><blockquote>“Good. Now extract the config values to environment variables.” “The tests look right, but add a case for expired tokens.”</blockquote><p>Each refinement narrows the gap between the draft and production readiness.</p><h3>Learning your partner’s limits</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Kg9fZXeuC4P0_Wr7" /></figure><p>The more you collaborate, the more you learn your AI’s profile, where it excels, where it stumbles.</p><h3>Where collaboration shines</h3><ul><li>Following Existing Patterns: When your codebase has clear examples, the AI extrapolates effectively.</li><li>Tedious Multi-File Changes: Adding a new CRUD entity touches models, routes, controllers, tests. Perfect for collaboration.</li><li>Refactoring at Scale: <em>“Convert all callback-based functions to async/await across fifty files.”</em></li></ul><h3>Where collaboration fails</h3><ul><li>Genuinely Novel Architecture: If you are designing something that doesn’t exist in your codebase, the AI has nothing to extrapolate from. It will struggle to align with your true intent, as architecture is a decision process, not just implementation.</li><li>Invisible Constraints: Performance budgets, security implications, tribal knowledge. The AI cannot see that <em>“we never use that library”</em> or <em>“this service is deprecated.”</em></li></ul><h3>The senior partnership</h3><p>Working with a high-reasoning agent isn’t about “prompting”, it is about pair programming. To get the best out of it, you must apply the same rigor you would with a human partner.</p><p>This means bringing Senior Developer skills to the conversation:</p><ul><li>Foresight: Anticipating architectural bottlenecks before they are coded.</li><li>Domain Authority: Enforcing the true meaning of business terms to prevent semantic drift.</li><li>Strategic Focus: Knowing what requires rigorous testing and what can be loose, or exactly what the frontend team expects beyond the JSON contract.</li><li>Business Context: Anchoring every decision in <em>why</em> the feature exists.</li></ul><p>The agent can write the code, but it cannot know the business reality. Your role is to inject that reality into the collaboration loop.</p><h3>Reviewing collaborative work</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*sBKGXd4iK9gnxi7q" /></figure><p>Collaboration produces larger changes than directed edits. A single session might touch ten files and add hundreds of lines. You cannot review this the same way you review a surgical diff.</p><h3>The trust calibration</h3><p>You are trusting more, so you must verify smarter. The questions shift from <em>“is this line correct?”</em> to:</p><ol><li>Is this the right approach? Does the architecture make sense?</li><li>Does it follow our patterns? Or did it invent something incompatible?</li><li>What did it miss? Edge cases, security, performance.</li></ol><h3>My review process</h3><ol><li>High-Level Structure First: What files changed? What is the shape of the solution?</li><li>Check Decision Points: Locate the places where the AI had to make a choice. These are the highest-risk vectors.</li><li>Scan for Red Flags: Unexpected dependencies, suspicious complexity, missing error handling.</li><li>Interrogate the Agent: Don’t just read the diff, ask the agent. <em>“Why did you choose this pattern?”</em> <em>“What trade-offs did you make?”</em> Treat the review as a dialogue. Often, the agent’s explanation reveals the flaw you missed in the code.</li></ol><p>The Tradeoff: You accept more risk in exchange for velocity. A 500-line feature in an hour instead of a day. The mitigation is tests, good coverage lets you trust the implementation and focus review on the choices tests can’t verify.</p><h3>The new normal</h3><p>I no longer switch between modes. My default state is collaboration.</p><p>I start every task by setting a direction for the agent. While it builds the infrastructure, the tests, and the boilerplate, I am already thinking about the next architectural move. When it gets stuck, I don’t take over, I guide it out.</p><p>The combination is powerful not because it is faster (though it is), but because it elevates the nature of the work. I am no longer paid to type syntax. I am paid to think, to design, and to lead a synthetic partner that never sleeps, never complains, and executes exactly as well as I can lead it.</p><p>The decisions remain mine. The architecture is my judgment.</p><p><em>This article is the first in a series exploring each level in depth. Next up: Level 2, how to shift from writing code to directing the agents that write it.</em></p><ol><li><a href="https://medium.com/a-42-journey/four-levels-of-ai-ride-the-wave-and-amplify-your-potential-4952e55f37c3">The four levels of AI integration</a></li><li><a href="https://medium.com/a-42-journey/ai-in-development-from-coder-to-conductor-d236ebc7e2e4">The art of directing AI</a></li><li><a href="https://medium.com/a-42-journey/ai-in-development-the-rise-of-the-autonomous-agent-d512c681d15b"><strong>Collaborating with AI on larger problems</strong></a></li><li><a href="https://medium.com/a-42-journey/ai-in-development-programming-intelligence-itself-2228883a67eb">When AI becomes the product</a></li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d512c681d15b" width="1" height="1" alt=""><hr><p><a href="https://medium.com/a-42-journey/ai-in-development-the-rise-of-the-autonomous-agent-d512c681d15b">Collaborating with AI on larger problems</a> was originally published in <a href="https://medium.com/a-42-journey">42 Studio</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The art of directing AI]]></title>
            <link>https://medium.com/a-42-journey/ai-in-development-from-coder-to-conductor-d236ebc7e2e4?source=rss----89676ea48d2a---4</link>
            <guid isPermaLink="false">https://medium.com/p/d236ebc7e2e4</guid>
            <category><![CDATA[ai-tools]]></category>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[productivity]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Jean-Baptiste Terrazzoni]]></dc:creator>
            <pubDate>Thu, 24 Jul 2025 20:16:44 GMT</pubDate>
            <atom:updated>2026-01-07T23:17:35.581Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*2XFfzWAwzSQcZmKk" /></figure><p>There is a mode of working with AI that sits between the passivity of autocomplete and the delegation of full autonomy. You select code, describe a desired state, and the AI executes the transformation. It isn’t predicting your next keystroke; it is rewriting logic based on your intent.</p><p>I call this Directing. You specify the transformation, the AI performs it, and you verify the result. This behavior is typical of models like Claude Haiku 4.5 or Sonnet 4.5, fast, precise, and optimized for low-latency instruction following.</p><p>On the surface, it seems trivial. Select, describe, accept. A glorified find-and-replace. But when I first started, “Make this better” produced chaos. “Add error handling” introduced the wrong abstractions. The AI was doing exactly what I asked, I just wasn’t asking with enough precision.</p><p>Directing is a skill. Developers who master it compress hours of work into minutes. Those who don’t simply generate bugs faster than they can fix them.</p><h3>What directing actually compresses</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*yc2mh3uCOqOWFxw0" /></figure><p>Every code change consists of two distinct acts: the decision and the transcription.</p><p>The decision is the intellectual spark. <em>“This function needs null checks.”</em> <em>“These callbacks should be async/await.”</em> The transcription is the mechanical labor: locating references, typing syntax, balancing brackets.</p><p>Directing compresses the transcription. The decision remains yours.</p><p>This distinction defines the boundary of trust. You are not outsourcing your judgment; you are outsourcing your keyboard. The architecture, the edge cases, the question of <em>“should we even do this?”</em>, that remains your responsibility.</p><h3>The precision hierarchy</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*GV4N-S_avoDL9VTO" /></figure><p>Vague input produces garbage. Precise input produces production-ready code. Precision isn’t just about verbosity, it’s about choosing the right <em>mechanism</em> of specification.</p><h3>Level 1: Constraints</h3><p>Sometimes the most critical instruction isn’t what you want, it’s what you <em>don’t</em> want.</p><ul><li>“Do not add external dependencies.”</li><li>“Keep the public API unchanged.”</li><li>“Do not modify the database schema.”</li></ul><p>Constraints are essential when you trust the AI’s implementation details but need to enforce boundaries. They act as guardrails, not blueprints.</p><h3>Level 2: Patterns</h3><p>Don’t describe the style. Show it.</p><pre>// Current error handling:<br>if (error) {<br>    console.log(error);<br>    return null;<br>}<br><br>// Transform to this pattern:<br>if (error) {<br>    logger.error(&#39;Operation failed&#39;, { error, context: operationName });<br>    throw new AppError(&#39;OPERATION_FAILED&#39;, { cause: error });<br>}<br><br>// Instruction: Apply this pattern to all error handlers in this file.</pre><p>The AI doesn’t have to guess your coding conventions. It sees them. Pattern-based prompts consistently outperform abstract descriptions.</p><h3>Level 3: Contracts</h3><p>The ultimate form of precision is a specification that is machine-verifiable: a test.</p><pre>test(&#39;retries failed requests with exponential backoff&#39;, async () =&gt; {<br>    const mockFetch = jest.fn()<br>        .mockRejectedValueOnce(new Error(&#39;timeout&#39;))<br>        .mockRejectedValueOnce(new Error(&#39;timeout&#39;))<br>        .mockResolvedValueOnce({ ok: true, data: &#39;success&#39; });<br>    <br>    const result = await fetchWithRetry(&#39;/api/data&#39;, { <br>        fetch: mockFetch,<br>        maxRetries: 3,<br>        baseDelay: 100 <br>    });<br>    <br>    expect(mockFetch).toHaveBeenCalledTimes(3);<br>});</pre><p>The instruction: <em>“Make this test pass.”</em> There is no ambiguity. The AI cannot misinterpret success because success is defined by the test runner.</p><h3>The verification discipline</h3><p>Precision gets you 80% of the way there. The remaining 20% is verification.</p><p>The AI is confident, not careful. It produces code that <em>looks</em> right with the same fluency that it produces code that <em>is</em> right. Your job is to tell the difference.</p><h3>Common failure modes</h3><p>1. Hallucinated APIs The AI invents methods that don’t exist or uses the wrong signatures. This is endemic with less common libraries.</p><pre>// AI wrote:<br>await redis.setWithExpiry(key, value, 3600);<br><br>// Actually exists:<br>await redis.set(key, value, { EX: 3600 });</pre><p>2. Semantic Drift The refactoring changes behavior, not just structure. The code looks equivalent but handles edge cases differently.</p><pre>// Original:<br>const result = items.find(x =&gt; x.id === id) || defaultItem;<br><br>// &quot;Refactored&quot;:<br>const result = items.find(x =&gt; x.id === id) ?? defaultItem;</pre><p>These behave differently when find() returns a falsy item.</p><p>3. Pattern Violations The AI solves the problem correctly but violates local conventions (e.g., using a raw Error instead of your custom AppError).</p><p>4. Missed Edge Cases The happy path works perfectly. Null inputs crash the system. Empty arrays throw exceptions. The AI optimizes for the common case.</p><h3>The verification checklist</h3><p>Before accepting any directed change:</p><ol><li>Read the Diff: Every line. If it’s too large to read, use collaboration instead.</li><li>Check Boundaries: What happens with null? Empty sets?</li><li>Run the Tests: Obvious, yet easily skipped.</li><li>Explain it to Yourself: If you can’t articulate what changed and why, you don’t understand it well enough to ship it.</li></ol><h3>The speed trap</h3><p>Direction is fast. Dangerously fast.</p><p>A diff appears in two seconds. Your brain pattern-matches against familiar structures. <em>“Looks like standard error handling. Ship it.”</em></p><p>I have done this. I have shipped code that worked in dev but failed in prod because I missed an edge case the AI also missed. I call this Approval Fatigue. When every change takes seconds, your review discipline erodes.</p><p>My rule: The faster the change, the slower the review.</p><p>A two-second generation deserves a two-minute review. The cost of finding bugs in production far exceeds the cost of careful verification now.</p><h3>Developing the instinct</h3><p>After a year of daily practice, I’ve developed instincts for effective direction.</p><h3>Scoping</h3><p>Not every task belongs in a directed change.</p><ul><li>Good for Direction: Single-function changes, clear transformations, refactoring within a file, diffs &lt;100 lines.</li><li>Bad for Direction: Multi-file features, architectural decisions, exploration.</li></ul><p>If I catch myself writing a long, multi-step prompt, that is a signal. Direction is for surgical strikes, not military campaigns.</p><h3>Prompt iteration</h3><p>The first prompt rarely produces the perfect result. Knowing <em>how</em> to iterate matters more than getting it right the first time.</p><ul><li>Narrow, Don’t Restart: <em>“That’s close, but use our </em><em>AppError class&quot;</em> is better than rewriting the initial prompt.</li><li>Add Constraints Incrementally: If the output drifts, add a constraint to pin it down. <em>“Same thing, but keep the function under 30 lines.”</em></li><li>Show What’s Wrong: <em>“The retry logic looks correct, but the delay calculation is linear, not exponential.”</em></li></ul><h3>Pattern recognition</h3><p>After reviewing hundreds of AI-generated diffs, I scan for specific red flags:</p><ul><li>Unusual Imports: Possible hallucinated dependencies.</li><li>Complex One-Liners: High risk of semantic drift.</li><li>Missing Error Handling: Edge cases likely ignored.</li><li>Magic Numbers: Constants that should be configurable.</li></ul><p>Speed in review comes from knowing <em>where</em> to look, not looking faster.</p><h3>The compound effect</h3><p>Every precisely specified change sharpens your ability to articulate intent. Every caught mistake refines your mental linter.</p><p>After a year of practice, I direct changes in seconds that would have taken minutes to type, and I catch problems before they ship. The goal isn’t just to accept changes faster. It is to develop the judgment that makes fast verification reliable. That judgment is the difference between an AI that accelerates you and an AI that generates technical debt.</p><p><em>This article is the first in a series exploring each level in depth. Next up: Level 2, how to shift from writing code to directing the agents that write it.</em></p><ol><li><a href="https://medium.com/a-42-journey/four-levels-of-ai-ride-the-wave-and-amplify-your-potential-4952e55f37c3">The four levels of AI integration</a></li><li><a href="https://medium.com/a-42-journey/ai-in-development-from-coder-to-conductor-d236ebc7e2e4"><strong>The art of directing AI</strong></a></li><li><a href="https://medium.com/a-42-journey/ai-in-development-the-rise-of-the-autonomous-agent-d512c681d15b">Collaborating with AI on larger problems</a></li><li><a href="https://medium.com/a-42-journey/ai-in-development-programming-intelligence-itself-2228883a67eb">When AI becomes the product</a></li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d236ebc7e2e4" width="1" height="1" alt=""><hr><p><a href="https://medium.com/a-42-journey/ai-in-development-from-coder-to-conductor-d236ebc7e2e4">The art of directing AI</a> was originally published in <a href="https://medium.com/a-42-journey">42 Studio</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The four levels of AI integration]]></title>
            <link>https://medium.com/a-42-journey/four-levels-of-ai-ride-the-wave-and-amplify-your-potential-4952e55f37c3?source=rss----89676ea48d2a---4</link>
            <guid isPermaLink="false">https://medium.com/p/4952e55f37c3</guid>
            <category><![CDATA[productivity]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[personal-development]]></category>
            <category><![CDATA[ai-integration]]></category>
            <dc:creator><![CDATA[Jean-Baptiste Terrazzoni]]></dc:creator>
            <pubDate>Thu, 24 Jul 2025 20:11:09 GMT</pubDate>
            <atom:updated>2026-01-07T23:17:21.908Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*2dO5jzDFx_RMrPw9" /></figure><h3>The four levels of AI mastery</h3><p>Two years ago, I wrote my first line of code with an AI watching. Copilot suggested a complete function body before I had even finished typing the signature. I accepted it without reading. The tests passed. I felt invincible.</p><p>A week later, I spent four hours debugging that same code. I had no idea how it worked because I hadn’t actually written it, I had merely approved it.</p><p>That failure taught me a crucial lesson: AI assistance isn’t binary. There is no single “right way” to use it. Instead, there are distinct levels of engagement, each demanding different skills, trust, and vigilance.</p><p>Most developers treat AI as a monolith, either embracing it fully or rejecting it entirely. This misses the nuance. The question isn’t <em>whether</em> to use AI, but <em>how deeply</em> to integrate it into your workflow.</p><p>After two years of building software alongside AI, I’ve mapped this landscape into four distinct modes:</p><ol><li>Assistance: It predicts your next move. You type less but stay in control.</li><li>Direction: It executes your commands. You specify precisely and verify carefully.</li><li>Collaboration: It explores and implements. You set direction, intervene, and iterate.</li><li>Integration: It becomes the product. You architect hybrid systems.</li></ol><p>Each level shifts the bottleneck. Misjudge the level for the task, and you risk wasting time micromanaging what could run autonomously, or blindly trusting what demands your expertise.</p><h3>Level 1: Predictive assistance</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*JxAdTFwBi1ApoMft" /></figure><p>This is the entry point: Copilot in the editor, ChatGPT in a browser tab. The AI observes your context and suggests the next logical step.</p><p>I remember the first time Copilot generated an entire validation function from a single comment. It felt like telepathy. The friction between thought and code dissolved. You still make every decision and own the architecture, but the AI handles the mechanical translation from intent to syntax.</p><h3>The approval paradox</h3><p>Speed is seductive. When suggestions appear faster than you can think, you begin to accept them reflexively. <em>Tab. Tab. Tab.</em> The code <em>looks</em> correct.</p><p>But three weeks later, you find yourself staring at a function you don’t recognize. I call this the Approval Paradox: as AI generation speed increases, your understanding of the code decreases, making that code progressively more dangerous.</p><p>The antidote is deliberate friction: treat AI suggestions like a code review. If you wouldn’t merge a colleague’s PR without reading it, do not accept an AI suggestion without reading it either.</p><p>The Mindset Shift: Speed is not the goal; <em>mental bandwidth</em> is. Use Level 1 to free your attention for the decisions that matter, not to abdicate decision-making entirely.</p><h3>Level 2: Directed execution</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*8o1_2vTxBWSNQCrb" /></figure><p>If Level 1 predicts what you are about to type, Level 2 executes what you command.</p><p>Select a block of code. Hit Cmd+K. Type: <em>&quot;Refactor this to use async/await.&quot;</em> The transformation happens in seconds. The structure changes, but the behavior remains invariant.</p><p>This is Directed Execution: you specify the transformation, the AI performs it, and you verify the result. The AI moves beyond autocomplete to <em>reasoning</em>.</p><p>The New Skill: Specification precision. Vague commands yield garbage. Precise instructions yield production-ready code.</p><h3>Three techniques for precision</h3><ol><li>Tests as Contracts: Write the test first, then instruct the AI: “Make this pass.”</li></ol><pre>test(&#39;retries failed requests up to 3 times&#39;, async () =&gt; {<br><br>    const mockFetch = jest.fn()<br>        .mockRejectedValueOnce(new Error(&#39;timeout&#39;))<br>        .mockRejectedValueOnce(new Error(&#39;timeout&#39;))<br>        .mockResolvedValueOnce({ ok: true });<br><br>    await fetchWithRetry(&#39;/api/data&#39;, { fetch: mockFetch });<br><br>    expect(mockFetch).toHaveBeenCalledTimes(3);<br>});</pre><ol><li>The test is unambiguous. The AI cannot misinterpret success.</li><li>Examples as Patterns: Demonstrate one transformation manually, then ask for the rest. “Transform error handling to match this pattern…”</li><li>Constraints as Guardrails: What you <em>exclude</em> is often more important. “No external dependencies,” or “Keep the public interface unchanged.”</li></ol><p>Directed execution is still execution. The AI is fast, not careful. It will hallucinate APIs or miss edge cases. My rule is simple: if I can’t explain what changed and why, I don’t accept it.</p><p>The Mindset Shift: The bottleneck moves from “how fast can I type” to “how precisely can I express intent.” Clarity of thought becomes the limiting factor.</p><h3>Level 3: Collaborative building</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*frJ09rlM65Nv504D" /></figure><p>Level 2 works for surgical strikes. But some tasks are structural.</p><p><em>“Add CSV export to the analytics dashboard. Follow our existing PDF export patterns.”</em></p><p>This isn’t a single command. It is a multi-file feature requiring exploration, architectural decisions, and iteration. The agent must understand your codebase, make choices, and adjust when you redirect it.</p><h3>The collaborative loop</h3><ol><li>Set Direction: “Add user authentication using next-auth…”</li><li>Observe: Watch the agent explore and plan.</li><li>Intervene: “Wrong library, we use jose, not jsonwebtoken.&quot;</li><li>Refine: “Good. Now extract config into environment variables.”</li></ol><p>You aren’t reviewing line-by-line; you are reviewing <em>trajectory</em>. Is the solution heading where it needs to go?</p><h3>Trust at the architectural level</h3><p>Collaboration requires a different breed of trust. You aren’t checking every line of a 500-line diff. You are checking: Is this the right <em>approach</em>? Does it follow our <em>patterns</em>? What did it <em>miss</em>?</p><p>This requires judgment. You need the ability to scan a large diff and grasp its shape, not just its syntax.</p><p>The Mindset Shift: Your role evolves from “implementer who types fast” to “architect who guides fast.” The thinking remains yours; the typing becomes shared.</p><h3>Level 4: Hybrid systems</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*0RsDnb4-vQ1e6Q55" /></figure><p>Levels 1–3 treat AI as a tool to <em>build</em> software. Level 4 is different: AI becomes a component <em>of</em> the software itself.</p><p>I realized this while building a news aggregator. I needed to deduplicate stories. String matching failed because headlines like “Fed raises rates” and “Powell announces policy shift” share no words but mean the same thing.</p><p>I needed the system to <em>understand</em> semantic equivalence. AI wasn’t helping me build the feature anymore. AI was the feature.</p><h3>The sandwich pattern</h3><p>The mistake developers make is treating AI as either magic or dangerous. The solution is Hybrid Architecture: code for constraints, AI for reasoning.</p><p>Every AI call in my system follows the Sandwich Pattern:</p><ol><li>Layer 1: Code (Preparation) Code decides what data the AI sees and how it is formatted. The AI never touches the database directly.</li><li>Layer 2: AI (Reasoning) The agent receives formatted data and a clear instruction: <em>determine whether these stories describe the same underlying event.</em> This is the task I cannot hardcode.</li><li>Layer 3: Code (Validation) The AI’s output is enforced by a strict schema (e.g., Zod). It must provide a valid ID or null. If validation fails, the system falls back gracefully.</li></ol><p>Code → AI → Code. This ensures AI’s flexibility operates strictly within your system’s constraints.</p><h3>Testing probabilistic systems</h3><p>AI systems are non-deterministic. Same input, different output. This breaks traditional testing strategies. My approach has three layers:</p><ol><li>Unit Tests for Code: The preparation and validation layers are deterministic. Test them normally.</li><li>Evals for AI: Maintain a dataset of test cases with known correct answers. Measure accuracy (e.g., “94% precision”). If it drops below a threshold, deployment fails.</li><li>Guardrail Tests: Test what happens when the AI misbehaves.</li></ol><pre>test(&#39;falls back to unique when deduplication fails&#39;, async () =&gt; {<br>    mockModel.mockReturnValue({ invalid: &#39;response&#39; });<br>    const result = await pipeline.process(newReport);<br>    expect(result.fallbackUsed).toBe(true);<br>});</pre><ol><li>The system must be robust to AI failures, not just AI successes.</li></ol><p>The Mindset Shift: You are no longer writing deterministic logic. You are orchestrating intelligence, designing systems that harness AI’s strengths while compensating for its weaknesses.</p><h3>Choosing the right level</h3><p>The skill isn’t mastering one level, it’s recognizing which level fits the task.</p><ul><li>Writing a familiar function? Use Level 1 (Assistance). Let autocomplete handle the routine.</li><li>Refactoring a single function? Use Level 2 (Direction). Surgical precision; verify the diff.</li><li>Adding a multi-file feature? Use Level 3 (Collaboration). Set direction, iterate together.</li><li>Building semantic search? Use Level 4 (Integration). AI is the capability, not the helper.</li></ul><p>The “Jarvis” fantasy wasn’t wrong, it was just incomplete. Real mastery isn’t having an omniscient assistant do everything for you. It’s knowing when to let AI autocomplete, when to command it precisely, when to collaborate as partners, and when to make it part of the product itself.</p><p><em>This article is the first in a series exploring each level in depth. Next up: Level 2, how to shift from writing code to directing the agents that write it.</em></p><ol><li><a href="https://medium.com/a-42-journey/four-levels-of-ai-ride-the-wave-and-amplify-your-potential-4952e55f37c3"><strong>The four levels of AI integration</strong></a></li><li><a href="https://medium.com/a-42-journey/ai-in-development-from-coder-to-conductor-d236ebc7e2e4">The art of directing AI</a></li><li><a href="https://medium.com/a-42-journey/ai-in-development-the-rise-of-the-autonomous-agent-d512c681d15b">Collaborating with AI on larger problems</a></li><li><a href="https://medium.com/a-42-journey/ai-in-development-programming-intelligence-itself-2228883a67eb">When AI becomes the product</a></li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4952e55f37c3" width="1" height="1" alt=""><hr><p><a href="https://medium.com/a-42-journey/four-levels-of-ai-ride-the-wave-and-amplify-your-potential-4952e55f37c3">The four levels of AI integration</a> was originally published in <a href="https://medium.com/a-42-journey">42 Studio</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Cursor: the compression of mechanical work]]></title>
            <link>https://medium.com/a-42-journey/cursor-a-developers-practical-guide-1825cf1241d4?source=rss----89676ea48d2a---4</link>
            <guid isPermaLink="false">https://medium.com/p/1825cf1241d4</guid>
            <category><![CDATA[productivity]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[developer-tools]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[code]]></category>
            <dc:creator><![CDATA[Jean-Baptiste Terrazzoni]]></dc:creator>
            <pubDate>Sat, 24 May 2025 07:39:32 GMT</pubDate>
            <atom:updated>2026-01-07T23:13:42.872Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*X6c8Imq1IzGwfMW8" /></figure><h3>Cursor: The compression of mechanical work</h3><p>Software engineering has always had a hidden cost: the gap between having an idea and making it work.</p><p>Consider a routine task: adding Google Login to an app. You know the plan in minutes, update the database, add the API route, configure the keys. The mental model is clear. But the implementation takes hours. You have to find the right files, type out the boilerplate code, fix the imports, and wrestle with configuration. This is the mechanical tax. It is the friction between your thought and the software.</p><p>Cursor reduces this tax. You describe what you want; the AI handles the typing.</p><p>What was once a three-hour slog becomes a forty-five-minute review session. But speed is just the bonus. The real shift is in your role: you are no longer the typist; you are the architect. The creative process stays with you, but the manual labor, the sheer act of writing code, is outsourced to a machine that types at the speed of light.</p><h3>Beyond autocomplete: The semantic map</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*TLvq5FNuRc1OEdTV" /></figure><p>Traditional autocomplete is shortsighted. It predicts the next word based only on the file open in front of you. It doesn’t know about the code you wrote yesterday in a different folder. It guesses words; it doesn’t understand systems.</p><p>Cursor breaks this model by reading your entire codebase. It builds a “semantic map” of your project, learning your patterns, your naming styles, and your architectural decisions.</p><p>The first time I grasped the power of this, I typed a vague instruction:</p><blockquote>“Refactor the user service to match how we handle organization entities.”</blockquote><p>It worked instantly. It didn’t just match keywords; it inferred the structure. It understood “user service,” it identified the pattern used for “organization entities,” and it applied that logic to the new context.</p><p>This is reasoning, not just guessing. The context isn’t just the text on your screen; it is your entire project, test outputs, documentation, and the unspoken rules of your team.</p><h3>The workflow: Four gears of interaction</h3><p>Cursor isn’t a single feature; it is a system with four distinct “gears,” each suited to a different kind of work.</p><h3>1. The flow state (Tab)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*sXToa95LZ50tvb9A" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*KjMPryKrf2jY6T9-" /></figure><p>Standard autocomplete predicts the next word. Cursor’s “Tab” predicts the next <em>thought</em>.</p><p>It generates entire functions, anticipates your next move, and understands the rhythm of editing. If you add a new requirement to a function, it immediately highlights all the other places in your code that need to be updated.</p><p>It feels less like a tool and more like a partner who is always one step ahead. After a few days, it stops suggesting generic “best practices” and starts suggesting <em>your</em> code, adopting your specific style and preferences.</p><h3>2. Inline mutation (Cmd+K)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*kgjuu3te2B0PfIA1" /></figure><p>Switching windows destroys focus. Going to a chat window to ask for a change breaks your flow. The Cmd+K interface lets you give instructions right where you are. You select code and describe the change:</p><blockquote>“Refactor this to use async/await.” “Add a limit of 100 requests per minute.” “Handle the case where the user is missing.”</blockquote><p>A “diff” (comparison view) appears in place. You accept or reject.</p><p>This turns refactoring from a chore into a rapid-fire review process. Changes that usually demand five minutes of careful editing happen in seconds of careful <em>verification</em>.</p><h3>3. Contextual query (Chat)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*lSI1uB9q6O7luk4O" /></figure><p>When you need to explore or understand, Chat provides an interface to ask questions about your specific codebase.</p><ul><li>“How does our caching system work?”</li><li>“Why would this test fail?”</li><li>“Trace the data flow from the API to the database.”</li></ul><p>The power lies in the reference system. You can tag specific files or folders (like @auth or @database) to give the AI exact context. It answers with facts about <em>your</em> system, not generic advice from the internet.</p><h3>4. Agentic building</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*cfuHLjHYWEgo0A2T" /></figure><p>This is the frontier. Agent mode handles multi-step tasks that require navigating files and running commands.</p><blockquote>“Add CSV export to the dashboard. Follow our existing PDF export patterns.”</blockquote><p>I watched it work: it searched the codebase to find the PDF logic, analyzed the pattern, implemented the backend code, updated the frontend, generated tests, ran them, saw a failure, <em>fixed its own failure</em>, and presented a complete solution.</p><p>It is disorienting. You stop coding and start supervising. You interrupt only if it goes off track. But the heavy lifting is done for you.</p><h3>The illusion of competence</h3><p>After months of daily use, I have learned that treating AI as magic is dangerous. It has specific weaknesses you must manage.</p><p>Novelty is Difficult The model excels at copying patterns. If you have done something before, it can do it again elsewhere. But creating a new architecture requires human leadership. If you ask it to design a system from scratch without guidance, it will produce a plausible-looking mess. You must break new problems into familiar steps.</p><p>Ambiguity Produces Garbage Vague instructions yield vague code. “Make this faster” achieves nothing. “Reduce response time by adding caching” works. Clear thinking is the requirement for clear code.</p><p>The “Looks Right” Trap This is the most dangerous pitfall. The code appears professional and correct.</p><p>I once shipped a bug because the generated code looked perfect and passed the tests. I hadn’t <em>understood</em> it; I had only <em>accepted</em> it.</p><p>The lesson: Decide your review level upfront.</p><ul><li>Prototype? Accept fast, fix later.</li><li>Internal Tool? Verify it works, ignore polish.</li><li>Payment System? Scrutinize every line. Test manually. Zero tolerance for errors.</li></ul><p>The question isn’t “Is the AI right?” It is “What is the cost if it’s wrong?”</p><h3>The skill of orchestration</h3><p>These limitations are not blockers; they are just the rules of the game.</p><p>Working with Cursor is like training a junior engineer who types incredibly fast but lacks judgment. At first, you watch them closely. Over time, you learn their strengths.</p><p>My approach has evolved:</p><ul><li>Chunk the New Stuff: Don’t ask for a complex system all at once. Ask for the basic structure. Then add the details. Break the big problem into small, solvable pieces.</li><li>Show, Don’t Just Tell: For unusual patterns, write one example by hand. Then tell the AI: “Do it like this.”</li><li>Set Boundaries: Often, it’s more effective to say what <em>not</em> to do. “No external libraries.” “Keep it simple.”</li></ul><p>The agent is not a black box. It is a partner. The better you understand it, the more value you get.</p><h3>Intent-driven development</h3><p>Once you master this, the bottleneck shifts again. If the machine can execute any clear instruction, the challenge becomes <em>giving clear instructions</em>.</p><p>Natural language is fuzzy. Code is precise. The bridge is the test.</p><p>I have started writing tests <em>before</em> the code exists. A test defines the goal: <em>user clicks buy → transaction succeeds</em>.</p><p>Then I tell the AI: “Make this test pass, following our payment patterns.”</p><p>The AI handles the mechanics, the logic, the API calls, the errors. I review the architecture. The test becomes the instruction, the intent, and the proof all in one.</p><h3>The new bottleneck</h3><p>Cursor compresses mechanical work. Tasks that used to take half my day now take an hour. The question remains: what do we do with the saved time?</p><p>The AI handles the how. The what and the why remain strictly human. A tool that builds the wrong feature perfectly is useless.</p><p>My value as an engineer used to be limited by how fast I could type and how much syntax I remembered. Now, my value is defined by:</p><ul><li>Vision: Knowing the right system to build.</li><li>Understanding: Knowing the problem deeply.</li><li>Taste: Knowing the difference between a clumsy solution and an elegant one.</li><li>Clarity: The ability to explain what I want so clearly that a machine can build it.</li></ul><p>Cursor doesn’t replace the engineer. It removes the barrier between thought and software, ensuring that the only limit to what you can build is how clearly you can think.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1825cf1241d4" width="1" height="1" alt=""><hr><p><a href="https://medium.com/a-42-journey/cursor-a-developers-practical-guide-1825cf1241d4">Cursor: the compression of mechanical work</a> was originally published in <a href="https://medium.com/a-42-journey">42 Studio</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What remains when machines handle everything?]]></title>
            <link>https://medium.com/a-42-journey/ai-architects-of-inversion-the-world-that-follows-94f05eb9df14?source=rss----89676ea48d2a---4</link>
            <guid isPermaLink="false">https://medium.com/p/94f05eb9df14</guid>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[innovation]]></category>
            <category><![CDATA[society]]></category>
            <category><![CDATA[future]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Jean-Baptiste Terrazzoni]]></dc:creator>
            <pubDate>Thu, 15 May 2025 22:50:57 GMT</pubDate>
            <atom:updated>2026-01-07T22:58:36.821Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*HtvSJSlpfC3cbUv-" /></figure><p><em>The question isn’t whether AI will do your job. It is what you will do when work becomes optional.</em></p><p>For the entire arc of human history, work meant survival. Labor produced value, value produced income, and income kept you alive. Work and survival were fused together, the central organizing fact of human existence.</p><p>That link is breaking.</p><p>It won’t happen overnight, and it won’t happen evenly. But as AI absorbs knowledge work and robotics solves physical labor, the connection between effort and survival weakens. Eventually, it snaps.</p><p>This forces us to confront a question we have never had to answer at scale: What happens when work stops being necessary?</p><h3>The photography precedent</h3><p>This has happened before.</p><p>For centuries, painters were valued for their technical skill, the ability to represent reality accurately on canvas. Portraits commanded high prices because capturing a likeness required years of rigorous training. Technical execution was the point.</p><p>Then cameras arrived.</p><p>Suddenly, perfect visual representation became trivial. Instant. Mechanical. Anyone could capture reality exactly as it appeared.</p><p>Did painting die? No. It was liberated.</p><p>Painters stopped competing with reality and started exploring what cameras <em>couldn’t</em> capture: emotion, interpretation, abstraction, meaning. Art stopped being about technical accuracy and became about expression and intention. The Impressionists, the Expressionists, the entire trajectory of modern art, all were made possible because mechanical reproduction freed painters from the burden of documentation.</p><p>AI is doing the same thing to work itself.</p><p>When execution becomes cheap, when anyone can produce competent writing, analysis, design, code, the question shifts from “how well can you do this?” to “why are you doing this at all?”</p><p>The economy starts rewarding intention over technique. Meaning over metrics. Genuine contribution over credentials.</p><h3>Work becomes signal</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*a4pwn3eY3JOj2RwM" /></figure><p>Today, when someone says “I am a lawyer” or “I work in finance,” it tells you almost nothing about who they are. Are they passionate about justice? Fascinated by markets? Or just paying off student loans?</p><p>You can’t tell. Work is conflated with economic necessity. Motivation is obscured.</p><p>When survival is decoupled from employment, work transforms into a signal.</p><p>If someone chooses to spend their finite time navigating legal complexity when they don’t <em>have</em> to, it is because they genuinely care. The choice itself becomes the information.</p><p>This doesn’t mean people stop working. It means motivation shifts from external compulsion to internal drive.</p><ul><li>From “I have to” to “I want to.”</li><li>From obligation to expression.</li></ul><h3>The gym paradox</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*M0I6ugblGm_IcA49" /></figure><p>Here is a pattern that predicts what is coming.</p><p>For millennia, physical strength was necessary for survival. Farming required muscle. Building required power. If you were weak, you didn’t eat.</p><p>Then machines arrived. Tractors replaced muscle. Factories automated manufacturing. Physical strength stopped being necessary for survival.</p><p>Did humans stop caring about physical fitness?</p><p>The opposite happened. We built gyms. We created entire industries around voluntary physical exertion. We invented marathons, CrossFit, and obstacle courses. People now <em>pay money</em> to exhaust themselves physically, precisely because they don’t have to.</p><p>What is no longer necessary for survival becomes valued for meaning and identity.</p><p>The same shift is coming for mental effort.</p><p>You don’t have to memorize facts; AI recalls everything. You don’t have to solve complex math; AI computes perfectly.</p><p>But choosing to think deeply when you could delegate, choosing to struggle with a problem when you could just ask for the answer, becomes meaningful <em>because</em> it is optional.</p><p>Intellectual effort transforms from an obligation to an identity. From “I think to get paid” to “I think because it makes me who I am.”</p><h3>The partnership</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*3cx1l7bJFAs2G-To" /></figure><p>As AI capabilities expand, the usual framing is competitive: <em>Will AI replace us?</em></p><p>This assumes a zero-sum game. The future is not about replacement; it is about complementarity.</p><ul><li>AI excels at: Processing information, recognizing patterns, optimizing systems, and executing with perfect consistency at scale.</li><li>Humans excel at: Embodied experience, emotional depth, contextual judgment, and caring about outcomes for reasons that aren’t rational.</li></ul><p>AI can manage global logistics, optimize energy grids, and coordinate supply chains. Humans provide the meaning and direction. We decide <em>what</em> is worth optimizing for. We care about the results in ways algorithms cannot, because caring is not a computation.</p><p>Consider the partnership between humans and dogs. Neither species became obsolete. Dogs brought heightened senses and loyalty; humans brought tools and planning. Together, both became more capable.</p><p>AI and humans are forming a similar symbiosis. AI manages the infrastructure of civilization. Humans fill it with purpose.</p><h3>The great clearing</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Dak9J1gxb0Da8hdG" /></figure><p>Imagine if the administrative overhead of modern life simply vanished.</p><p>The hours spent navigating bureaucracy. The scheduling. The logistics. The password management. The cognitive load that drains energy without creating meaning.</p><p>What would you do with that freed attention?</p><p>Maybe you would focus on what feels authentically human. Deep relationships. Community. Creating things because they express who you are. Experiencing life directly rather than managing its complexity.</p><p>Not because economic circumstances force you to. But because you finally <em>can</em>.</p><h3>The question you are not ready to answer</h3><p>This shift surfaces something uncomfortable.</p><p>If you didn’t need money to survive, what would you actually do with your time?</p><p>Many people do not know. They have never had to answer it. Work has always been a necessity, not a choice. The idea of freely choosing your purpose feels foreign. Even frightening.</p><p>But this is precisely the question the future poses.</p><p>When machines handle necessity, human purpose becomes the real work.</p><p>Strip away everything that can be automated, and what remains?</p><ul><li>Embodied presence.</li><li>Being there for someone who needs you.</li><li>Emotional connection.</li><li>Making art because it feels true.</li><li>Helping someone simply because you want to.</li></ul><p>These are not consolation prizes we settle for because we can’t compete with AI. These are the things that actually make life worth living.</p><h3>The shift</h3><p>The transformations in this series are connected.</p><ol><li>When execution becomes cheap, the middle collapses. Value moves to the extremes: pure judgment or pure humanity.</li><li>When knowledge becomes free, interpretation becomes valuable. It’s not what you know, but how you play the notes.</li><li>When work stops being about survival, it becomes about expression.</li></ol><p>The world is shifting from rewarding <em>what you can do</em> to rewarding <em>who you are</em>, your judgment, your taste, your relationships, your capacity for care.</p><h3>Your turn</h3><p>You don’t need permission to participate in this shift. The tools exist. The intelligence is available.</p><p>What is required is answering the uncomfortable questions:</p><ul><li>What would you do if you didn’t need the money?</li><li>What work would you choose as expression rather than obligation?</li><li>What do you care about enough to pursue when no one is forcing you?</li></ul><p>The future isn’t about humans becoming obsolete. It is about humans finally being free to focus on what we were built for, while machines handle what they were built for.</p><p>Not competition. Partnership. Not replacement. Liberation.</p><p>The revolution isn’t coming. You are in it.</p><p>The only question is whether you will drift through it passively, or use it deliberately to build a life around what actually matters.</p><p>That answer is yours to write.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=94f05eb9df14" width="1" height="1" alt=""><hr><p><a href="https://medium.com/a-42-journey/ai-architects-of-inversion-the-world-that-follows-94f05eb9df14">What remains when machines handle everything?</a> was originally published in <a href="https://medium.com/a-42-journey">42 Studio</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The collapse of the middle]]></title>
            <link>https://medium.com/a-42-journey/ai-architects-of-inversion-the-collapse-of-execution-5edb32e81920?source=rss----89676ea48d2a---4</link>
            <guid isPermaLink="false">https://medium.com/p/5edb32e81920</guid>
            <category><![CDATA[future-of-work]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[innovation]]></category>
            <category><![CDATA[strategy]]></category>
            <category><![CDATA[creativity]]></category>
            <dc:creator><![CDATA[Jean-Baptiste Terrazzoni]]></dc:creator>
            <pubDate>Thu, 15 May 2025 22:14:32 GMT</pubDate>
            <atom:updated>2026-01-07T22:57:38.952Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*PlZ2-GxwzC3r1W4O" /></figure><p><em>When execution becomes cheap, the comfortable middle disappears.</em></p><p>You have felt the shift. You might even be using AI daily. But something larger is happening beneath the surface, a structural change in the physics of value.</p><p>Here is the pattern: When a fundamental resource goes from scarce to abundant, everything built on that scarcity inverts.</p><p>When metalwork was rare, blacksmiths commanded premium wages. Then factories made metalwork cheap. The blacksmith’s expertise collapsed into a commodity. Who survived? The artist who made bespoke ironwork. The engineer who designed the factory. The extremes.</p><p>When distribution was scarce, publishers controlled culture. Then the internet made distribution free. The gatekeepers lost their power. Who survived? The creator with a genuine audience. The curator with trusted taste. The extremes.</p><p>Now, it is happening to intelligence itself.</p><h3>The hollowing out</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*sXjCFiSFLwjy1Rh6" /></figure><p>For the last century, professional work had a massive, comfortable middle layer.</p><ul><li>Top: Executives and strategists setting direction.</li><li>Bottom: Physical workers building and maintaining.</li><li>Middle: A vast class of knowledge workers, analysts, designers, writers, managers, translating strategy into execution.</li></ul><p>This middle is where most educated professionals live. You learned a skill, got a credential, and spent your career doing the translation work: taking abstract goals and turning them into concrete outputs.</p><p>That middle is being compressed into software.</p><ul><li>The analyst synthesizing data? AI does the first pass instantly.</li><li>The designer iterating mockups? AI generates fifty options before breakfast.</li><li>The writer drafting reports? AI produces clean copy in seconds.</li><li>The project manager tracking dependencies? AI handles the logistics without fatigue.</li></ul><p>A law firm that once needed fifteen associates for document review now needs three. An agency that staffed twelve copywriters now runs with four.</p><p>The middle isn’t just shrinking. It is evaporating.</p><h3>Value moves to the edges</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*AtRN4vEs33FvglYM" /></figure><p>As the middle collapses, value concentrates at two distinct poles.</p><h3>The top: Pure judgment</h3><p>Strategy. Vision. The ability to decide what matters when the data is ambiguous. The courage to make a call with incomplete information and own the consequences.</p><p>This work cannot be delegated because it requires skin in the game. A CEO still decides the company’s future. An investor still judges the validity of the opportunity. AI informs these decisions; it does not make them.</p><h3>The bottom: Pure humanity</h3><p>Physical presence. Emotional attunement. The ability to read a room, sense the unspoken, and care about the outcome.</p><p>The nurse noticing a change in a patient’s breathing. The therapist holding space for crisis. The plumber diagnosing a sound in the wall. This work cannot be delegated because it requires a body, a relationship, or both. It happens in physical reality, where context is infinite.</p><p>Everything in between, the translation layer, the “take input and produce output” layer, is being automated.</p><h3>The great inversion</h3><p>Here is the irony we are just beginning to understand:</p><p>The work we spent decades elevating, “knowledge work,” white-collar careers, the “skilled” labor of the office, turns out to be the easiest to automate. It is structured. It is rule-based. It is reducible to patterns.</p><p>The work we systematically undervalued, care work, trades, emotional labor, turns out to be the hardest to automate. It is contextual. It is embodied. It is irreducibly human.</p><ul><li>Drafting a contract? Automatable.</li><li>Counseling a frightened client? Human.</li><li>Categorizing transactions? Automatable.</li><li>Helping a business owner survive a cash crunch? Human.</li></ul><p>The “hard” skills are becoming commodities. The “soft” skills are becoming the premium.</p><h3>The Beethoven problem</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*DnicThYldB5kqsXq" /></figure><p>For centuries, knowledge was power because access was scarce. If you knew the law, the medicine, or the code, you had leverage.</p><p>AI ends the information advantage.</p><p>Every framework, every fact, every best practice is now accessible to anyone in seconds.</p><p>But here is what survives:</p><p>Beethoven’s sheet music is free. Every note is available to anyone. But not every performance is equal. What makes a pianist great isn’t knowing the notes, everyone has the notes. It is the interpretation. The expression. The choices made in the silence between the keys.</p><p>AI gives everyone the notes. The interpretation is still yours.</p><p>The technical know-how is becoming a utility. What remains valuable is how you play: your judgment, your taste, your perspective.</p><h3>What survives?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*pLZ0CazxRKw3ZyHh" /></figure><p>The question isn’t “Can you use AI?” By next year, that will be table stakes.</p><p>The question is: When everyone has the same execution capabilities, what makes <em>you</em> valuable?</p><p>Three things survive the collapse:</p><p>1. Reputation The track record you have built. The trust you have earned. People do not hire capabilities; they hire people they believe will use those capabilities wisely.</p><p>2. Relationships The people who choose to work with you because they believe in your perspective. When capability is a commodity, loyalty and connection become the scarcity.</p><p>3. Point of View What you notice that others miss. What you care about. AI can execute anything, but it cannot <em>care</em> about anything. Your values and your specific way of seeing the world are the only things that cannot be replicated.</p><h3>The uncomfortable choice</h3><p>The comfortable middle, where you could be “pretty good” at execution and build a stable career, is gone.</p><p>You have a choice between two directions:</p><ol><li>Move Up: Toward pure judgment. Develop the strategy, the taste, and the vision to direct the machines.</li><li>Move Down: Toward pure humanity. Develop the skills that require presence, empathy, and the physical world.</li></ol><p>The middle path, being a competent executor of knowledge work, is a race to the bottom against software that costs zero. You cannot win that race.</p><p>This isn’t about whether AI takes your job. It’s about whether you are building value that survives when execution is free.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5edb32e81920" width="1" height="1" alt=""><hr><p><a href="https://medium.com/a-42-journey/ai-architects-of-inversion-the-collapse-of-execution-5edb32e81920">The collapse of the middle</a> was originally published in <a href="https://medium.com/a-42-journey">42 Studio</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to actually use AI]]></title>
            <link>https://medium.com/a-42-journey/applied-intelligence-in-your-life-d904924b8c99?source=rss----89676ea48d2a---4</link>
            <guid isPermaLink="false">https://medium.com/p/d904924b8c99</guid>
            <category><![CDATA[productivity]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[self-improvement]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[future-of-work]]></category>
            <dc:creator><![CDATA[Jean-Baptiste Terrazzoni]]></dc:creator>
            <pubDate>Tue, 13 May 2025 18:04:37 GMT</pubDate>
            <atom:updated>2026-01-07T22:56:29.285Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*nN2Po1chpN8xMKf0" /></figure><p><em>You understand the shift. Now, what do you do about it?</em></p><p>Most people use AI incorrectly.</p><p>They treat it like a search engine with a personality, something to consult when stuck, then close the tab to return to “real work.” They use it as an occasional helper. A novelty.</p><p>This is like having a full-time research team, a senior editor, a data analyst, and a strategist on call 24/7, and only asking them for help once a week when you can’t figure something out yourself.</p><p>The gap between those thriving and those falling behind isn’t access. Everyone has access. The difference is whether AI is your starting point or your last resort.</p><h3>You are a director now</h3><p>Here is the mental shift that changes everything: Stop thinking of AI as a tool. Start thinking of yourself as a director.</p><p>You now have on-demand access to a team:</p><ul><li>The Researcher: Synthesizes any topic in minutes.</li><li>The Writer: Produces drafts instantly in any tone.</li><li>The Analyst: Finds patterns in data you would miss.</li><li>The Strategist: Pressure-tests your logic.</li></ul><p>They are not perfect. They make mistakes, they need clear direction, and they cannot tell when they are hallucinating. But they are fast, cheap, tireless, and always available.</p><p>Your job is no longer to play every role yourself. Your job is to direct them, and then use your judgment to decide what is actually good.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*sx9gA4eLC_ThODmK" /></figure><p>Imagine a founder who spends 60% of their time on tasks they are mediocre at: writing copy, designing landing pages, digging through competitor data. Now, suppose AI handles the first pass on all of it. They review, refine, and decide. Their output triples. More importantly, they stop doing the work they are bad at and focus entirely on product vision.</p><p>The unlock isn’t “AI does my job.” It is “AI does the parts of my job that aren’t really my job.”</p><h3>First pass, not last resort</h3><p>This is the habit that separates the winners from the observers:</p><p>Before you start any cognitive task, ask: “Can AI do the first pass?”</p><p>Not “Can AI do this perfectly?” Not “Should I let AI do the whole thing?” Just: <em>Can it give me a starting point?</em></p><p>The answer is almost always yes.</p><ul><li>Email: Have AI draft the response before you type a word.</li><li>Analysis: Have AI summarize the raw data before you open Excel.</li><li>Planning: Have AI outline the project steps before you start scheduling.</li><li>Research: Have AI synthesize the current state of knowledge before you open Google.</li></ul><p>Right now, these are mostly text-based applications. But do not mistake the current limitation for the final state. We are rapidly building the tools to extend this “first pass” capability to every domain: complex codebases, 3D design, video production, and physical logistics. The principle remains the same.</p><p>You are not outsourcing your judgment. You are outsourcing the grunt work. You are eliminating the friction of the task itself.</p><h3>Context is the skill</h3><p>The difference between useless output and breakthrough output is context.</p><p>Most people type a vague request, get a generic response, and conclude AI is hype. They are right, because they gave it nothing to work with.</p><p>Think of it like directing actors. “Be sad” gets you a cliché. “You just found out your childhood home is being demolished, and you are standing in the empty living room remembering your father teaching you to dance” gets you a performance.</p><p>Compare these two prompts:</p><p>Weak: <em>“Write an email to a client.”</em></p><p>Strong: <em>“Write an email to Sarah, the CFO at Meridian. We are three weeks behind on the implementation. She is fair but frustrated, she cares about results, not excuses. I need to acknowledge the delay, explain the cause without being defensive, and propose a realistic new timeline. Keep it under 150 words. Professional but warm.”</em></p><p>The second prompt takes 30 seconds longer to write. The result is actually usable.</p><p>The skill isn’t “prompt engineering.” It is clarity of thought. It is knowing exactly what you want before you ask for it. It is the exact same skill required to collaborate effectively with another human being.</p><h3>Iterate, don’t evaluate</h3><p>Do not judge AI on its first output. Judge it on how fast you can iterate toward excellence.</p><ul><li><em>Too formal?</em> “Make it warmer, keep it sharp.”</li><li><em>Missing nuance?</em> “Add a specific example of the implementation benefits.”</li><li><em>Wrong angle?</em> “Give me three completely different approaches.”</li></ul><p>You can explore five strategic directions in the time it used to take to write one mediocre draft.</p><p>The moment you catch yourself grinding through busywork, stop. Ask: “What part of this can I turn into a prompt?”</p><h3>Where it breaks</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*dlYogVHXjfrbHOlf" /></figure><p>AI will confidently give you garbage if you do not understand its limits.</p><ol><li>It has no experience. It has never walked a factory floor, felt the tension in a boardroom, or navigated office politics. It acquired its intelligence entirely through the world of words. It knows the description of reality, not reality itself. Anything requiring embodied intuition is invisible to it.</li><li>It doesn’t know what it doesn’t know. It sounds equally confident when it is right and when it is hallucinating. It will not warn you. You must know the territory well enough to spot the map’s errors.</li><li>It cannot want. It optimizes for your request, not your goal. It cannot tell you if you are solving the wrong problem. Strategy, values, and priorities remain 100% human.</li></ol><p>The rule: Use AI to expand your options, then use your judgment to choose.</p><h3>The one thing to do this week</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*gVcZymMBLwpY26Zs" /></figure><p>Do not try to transform your entire workflow overnight. That is how people fail.</p><p>Instead, pick one task you do regularly, something that takes at least 30 minutes and involves processing information. Drafting emails. Meeting prep. Summarizing reports.</p><p>For the next week, start that task with AI every single time.</p><p>Force yourself through the awkwardness of learning to direct instead of do. Notice when context improves the output. Notice how much faster the work moves when you aren’t starting from zero.</p><p>By Friday, you will have a new default. Then, pick another task.</p><p>This is not about becoming a “tech person.” It is about building the habit of starting with leverage instead of friction.</p><h3>The gap is opening</h3><p>Two years from now, using AI for knowledge work will be as obvious as using Google. Everyone will do it. The advantage will be gone.</p><p>But right now? The gap is wide.</p><p>Most people are hesitating. They are waiting for permission or perfection. Meanwhile, a small group is building the muscle memory of the future.</p><p>Pick one task. Start with AI. Do it today.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d904924b8c99" width="1" height="1" alt=""><hr><p><a href="https://medium.com/a-42-journey/applied-intelligence-in-your-life-d904924b8c99">How to actually use AI</a> was originally published in <a href="https://medium.com/a-42-journey">42 Studio</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>