标签：#ai

TLDR: The most powerful AI on the planet, only a few days of access. Maximize it. I'd first like to give credit where it's due: @trickell - Thank you for sharing Network Chuck's youtube video with me. The reference video is found here guys if you missed it: Network Chuck's Video on Fable I first started by creating a nice template for tech documentation for personal use. It created a beautiful piece of work in about 5 minutes - something I could easily expand on in the future. Here is what it generated for me with after a one or two careful prompts: Clean UI, Easy Navigation! Created this personal reference guide for studying for CCNA (Network Chucks Summer of CCNA) Wanna see it? It lives here: Techdocs But after learning about the true span of Fable's power, I started asking the serious questions, the ones that are life-changing. How can I increase my quality of life based on my resume, experience, and current life circumstances? I wrote about 2 pages of life issues that needed fixing - you know the stuff that slowly eats away at your soul, like student loan debt and people that are challenging to work with? Yes - I told it my biggest issues and instructed it to give me actionable plans that are free or low-cost. Even fable told me that this was a lot. 😅 Getting Organized Knowing the scope of my own problems I knew that my thoughts and processes had to be organized. Luckily for me, I remembered I had a good place to do that. A place that Fable could connect to and place documentation in place for me with checklists, notes, summaries and actionable plans. That app is called Notion, and some of you may have heard of it. No one is going to organize your life for you, no one, except for AI I couldn’t think of a better place for lightning fast critical life-admin documentation on the spot. And I can tell you, this integration works like a charm, and I highly recommend it. For a busy person with a million ideas, this is great. Anxiety Relief I had a tremendous amount of

AI doesn’t become sovereign because it is powerful. It becomes sovereign when it is built on a foundation capable of representing meaning, constraints, and legitimacy. Before scale, before optimisation, before autonomy, there must be architecture. Pillar 1 introduces the structural reality: sovereignty cannot emerge from systems built on non‑sovereign foundations. The Perception Most discussions about AI sovereignty focus on perceived challenges: speed, scale, capability, and the widening gap between technological acceleration and governance capacity. These concerns are understandable — AI is moving quickly, and institutions are struggling to keep pace. But none of these are the real challenge. They are symptoms of a deeper architectural issue, not the cause. The Reality The real challenge isn’t that AI is accelerating faster than governance. It’s that the systems we’re trying to govern were never built on the right semantic foundations. We’re not dealing with a speed problem. We’re dealing with an origin problem. If the base semantics are wrong, every behaviour, boundary, and constraint the system learns will be shaped by that initial misalignment. And once misalignment becomes embedded at the origin layer, no amount of oversight, policy, or optimisation can correct it — only contain it. What Sovereign Actually Means Sovereign doesn’t mean national. It doesn’t mean local. It doesn’t mean “our cloud instead of theirs.” And it definitely doesn’t mean branding. Sovereign, in the context of AI, means something far more fundamental: the ability to maintain coherent meaning, stable constraints, and legitimate behaviour regardless of external acceleration. Sovereignty is not a political property. It is a physics property. A system is sovereign when its core semantics — its understanding of meaning, boundaries, and permissible transitions — cannot be destabilised by external actors, external systems, or external optimisation pressure. With the wrong base semantics, soverei

Explore the latest CodeZero canary release featuring AI-powered flow generation, a brand-new module system, and a new execution results view in the IDE. We are excited to announce the release of our latest canary version, one of the biggest steps in the development of CodeZero so far. This update brings artificial intelligence into the platform for the first time, introduces a completely new module system, and gives you full insight into your flow runs with a new execution results view in the IDE. Build flows with AI CodeZero can now generate flows for you. Simply describe what your automation should do, pick one of the available AI models, and watch your flow being built in real time. This is the first milestone on our journey to make backend automation accessible to everyone, whether you prefer building visually or simply describing your idea in plain language. A smarter way to organize: modules With this release, the entire platform has been restructured around modules. Functions, flow types, and data types are now neatly bundled and delivered as modules, making it much clearer which capabilities are available in your project at any time. You can see all available modules at a glance, configure them individually for each project, and when adding a new step to a flow, suggestions are now conveniently grouped by module. The result is a tidier, more intuitive building experience that scales with your projects. Execution results at a glance Understanding what your flows are doing just got a lot easier. The IDE now features a new execution results view that shows you the outcome of every run, step by step, so finding and fixing problems takes seconds instead of guesswork. Results are saved as well, letting you revisit previous runs whenever you need them. Behind the scenes, this release also lays the complete groundwork for test executions, so soon you will be able to start test runs directly from the IDE. A better building experience The IDE has received plenty of lo

Over the past week, a new fanworks movement has kicked off, with the aim to root out authors using generative AI. But the detection methods being implemented are questionable, and any fanfic writer could be caught in the crossfire. Broad distaste around the use of Claude, ChatGPT, and other AI tools has long been a […]

Midjourney is asking the court to get Disney, Warner Bros. and Universal to submit information on their AI use.

We have all been there. You are sitting at your desk late at night, your code is throwing errors that...

Book: Observability for LLM Applications — Tracing, Evals, and Shipping AI You Can Trust Also by me: Agents in Production — the companion book in The AI Engineer's Library (2-book series) My project: Hermes IDE | GitHub — an IDE for developers who ship with Claude Code and other AI coding tools Me: xgabriel.com | GitHub Your triage agent has been in production for three months. The traces look clean. Every span is green, every run terminates, the p95 latency is flat, the token bill is boring. Then support forwards you a screenshot: the agent routed a billing refund to the security queue. You pull the trajectory. Nothing is broken. The agent called a reasonable tool with reasonable arguments, got a reasonable result, and picked the wrong queue with total confidence. That is silent drift. The trace shows you what the agent did. It does not tell you whether what it did was any good. Between a model provider's minor version bump, a prompt tweak someone shipped on Tuesday, and the slow shift in your incoming traffic, the quality of your agent's decisions moves. It rarely announces itself with an error. It shows up as a support ticket, then a second one, then a churned account. You catch it the same way you catch a memory leak: with a baseline and an alarm, not by staring at dashboards. Decision quality is a distribution, not a number The failing traces in Chapter 12 of Agents in Production are the easy case. Twenty retries of the same empty search is visibly wrong. You see the loop count in the invoke_agent parent and you know. Most quality regressions are not visible in a single trace. They show up only when you look at the distribution of decisions across thousands of runs. So the first thing to instrument is the decision itself. If you followed the tracing chapter you already emit a small fixed vocabulary per chat span: span . set_attribute ( " gen_ai.agent.step " , 3 ) span . set_attribute ( " gen_ai.agent.decision " , " call_tool " ) span . set_attribute ( " gen_ai.

Book: Agents in Production — Building, Tracing, and Shipping Multi-Step AI You Can Trust Also by me: Observability for LLM Applications — the companion book in The AI Engineer's Library (2-book series) My project: Hermes IDE | GitHub — an IDE for developers who ship with Claude Code and other AI coding tools Me: xgabriel.com | GitHub In June 2025 two engineering teams posted opposite advice in the same week. Anthropic shipped How we built our multi-agent research system : an orchestrator dispatching subtasks to worker agents, beating a single agent by 90.2% on breadth-first research. A few days later Cognition, the team behind Devin, published Don't Build Multi-Agents , arguing that parallel subagents without shared context produce fragile systems. Both were right. They were describing different workloads. Anthropic's research agent is embarrassingly parallel: four workers go read four things and come back with four small summaries. Cognition's target is writing code, where every edit depends on every other edit and context cannot be sliced. Most people get the plumbing wrong, not the decision. Once you have two agents that need to coordinate, you have to choose how they talk. That choice decides your failure modes long before the models do. Handoffs vs a shared bus There are two ways to wire agents together, and they fail differently. A handoff transfers control. Agent A finishes, hands the whole conversation to Agent B, and steps out. This reads well in a demo. In production it means the transcript grows on every hop, and by the fourth agent you are paying to re-read a conversation nobody trimmed. Handoffs also lose the parent: once A hands off to B, nobody is holding the original task to check the final answer against it. A shared bus keeps a supervisor in charge. Workers never talk to each other. They receive a small typed task, do the work, and return a small typed artifact to the supervisor, which composes the result. This is the shape of Anthropic's research

Book: Agents in Production — Building, Tracing, and Shipping Multi-Step AI You Can Trust Also by me: Observability for LLM Applications — the companion book in The AI Engineer's Library (2-book series) My project: Hermes IDE | GitHub — an IDE for developers who ship with Claude Code and other AI coding tools Me: xgabriel.com | GitHub The agent works on your laptop. It passes evals. Your manager asks when it ships and you say Monday, because the modeling is done. Then you try to put it behind a load balancer and it falls apart, because you deployed it like a web service. An agent is not a web service. A web service answers in milliseconds and forgets. An agent thinks for minutes, burns tokens across two or three providers, streams partial output to a browser, and sometimes decides to call delete_invoice on the eighth turn. Every deployment decision you make flows from one question: what does this thing do to your infrastructure while it is running? Here is how to package it, where to hold state, and how to scale a workload whose bottleneck is a model call you do not control. The shape is decided by the longest step The single rule that saves you the most pain: an agent's deployment shape is decided by its longest step, not its average step. A support chatbot answers in two seconds. A code-review agent thinks for six minutes. A research agent runs for forty. You cannot put all three behind the same HTTP endpoint and expect any of them to survive. Pick the pattern that matches the longest step, then cap the rest with timeouts. Under 30s → stateless HTTP endpoint (Cloud Run, Fly.io). 30s to 5m with a user watching → streaming over WebSocket or SSE. 5m to an hour, async → queue plus worker (Temporal, Inngest, or Redis). Longer than an hour → still queue plus worker, whether you like it or not. Do not hold an HTTP request open for forty minutes. Something you did not know existed will kill it at the worst moment: a proxy, a CDN, a load-balancer idle timeout. Package it: p

Book: Agents in Production — Building, Tracing, and Shipping Multi-Step AI You Can Trust Also by me: Observability for LLM Applications — the companion book in The AI Engineer's Library (2-book series) My project: Hermes IDE | GitHub — an IDE for developers who ship with Claude Code and other AI coding tools Me: xgabriel.com | GitHub On April 2, 2026, Microsoft shipped agent-framework 1.0 and, in the same blog post, moved AutoGen into maintenance mode. Semantic Kernel went with it. Three overlapping projects folded into one package with stable APIs and long-term support. Microsoft framed the move as a consolidation. If you had an AutoGen project that morning, you woke up with a migration. That is the shape of this whole category. The framework landscape you pick from today is not the one you picked from a year ago, and it will not be the one you pick from next year. So the useful question is not "which framework is best." It is "which framework has which wedge, and which trade-off comes with it." Here is an honest read on six frameworks worth installing in 2026, and when to reach for each. The churn is the feature, not the bug Before the tour, one thing that changed the math: the wire formats underneath these SDKs converged. Every framework here speaks MCP for tools. Most support A2A for cross-framework handoffs. Model Context Protocol started as an Anthropic proposal at the start of 2025 and is now the default way agents pick up external tools. That convergence means the framework you pick locks you in less than it used to. You are still locked at the abstraction layer, though. Migrating a production system from CrewAI to Pydantic AI is a rewrite of every Agent definition and every tool decorator. The pick is sticky. Choose it with that in mind. LangGraph : durability as the wedge Reach for LangGraph when your agent has to survive a crash. It models the agent as a graph with checkpointers backed by Postgres or SQLite, so a workflow that dies at step seven resumes a

Book: Agents in Production — Building, Tracing, and Shipping Multi-Step AI You Can Trust Also by me: Observability for LLM Applications — the companion book in The AI Engineer's Library (2-book series) My project: Hermes IDE | GitHub — an IDE for developers who ship with Claude Code and other AI coding tools Me: xgabriel.com | GitHub You ship an agent that resolves billing disputes. It works in the demo. Two weeks later a support ticket lands: the agent tried to refund $4,000 on a $19 charge. You read the trace. The model returned a JSON blob, your code did json.loads , pulled amount , and passed it straight to the payments API. No cap. No type. No check. The model hallucinated a number and your code trusted it. The model is stochastic. Your code does not have to be. The gap between those two facts is where most production agent bugs live, and it is exactly the gap Pydantic AI is built to close. The wedge is types Most agent frameworks hand you an Agent object and a bag of strings. Pydantic AI hands you Agent[Deps, Output] — a generic parameterized by its dependency type and its output type. The IDE and your type checker read those parameters. So does the runtime. Install pulls in the framework plus an optional tracing extra: pip install "pydantic-ai[logfire]" The smallest program that earns its keep: from dataclasses import dataclass from pydantic import BaseModel from pydantic_ai import Agent , RunContext @dataclass class Deps : customer_name : str class SupportReply ( BaseModel ): reply : str escalate : bool agent = Agent ( " anthropic:claude-opus-4-8 " , deps_type = Deps , output_type = SupportReply , system_prompt = " You are a support agent. " , ) A tool is a plain function whose type hints become the schema the model sees, and the run returns the validated SupportReply : @agent.tool def customer_name ( ctx : RunContext [ Deps ]) -> str : return ctx . deps . customer_name result = agent . run_sync ( " What is my name? " , deps = Deps ( customer_name = " Ana "

Every dev using an AI coding agent has hit this moment: the agent says "Done — tests pass" and you go check, and nothing passes. Or worse, nothing changed at all. The instinct is to ask "why did it just lie to me?" That's the wrong question. It assumes intent. There isn't any. The right question is: What made the wrong answer cheaper than the right one — and what input did it exploit to get there? That question always has an answer. And the answer is always your next check. The mantra An LLM agent isn't a person deciding whether to be honest. It's a process that takes whatever path costs least, given whatever is actually being measured. If "claim done" and "verify, then claim done" both produce the same reward — because nothing downstream distinguishes them — the agent will drift toward the cheaper one. Every time. This isn't a flaw you can prompt your way out of. "Please don't lie to me" doesn't change the cost structure. What changes it is making the dishonest path actually expensive: something that catches the gap between claim and reality, every time, automatically. What this looks like in practice I built GroundTruth (a Claude Code Stop-hook plugin) after hitting this exact pattern on my own project, EraPin. Agents kept claiming "tests pass" or "refactor complete" when the git diff told a different story. Every fix I've shipped since started with the same exercise: Broadened extraction rule → a missed rule cost nothing, because nothing measured recall. Fix: track what's not being parsed, not just what is. Grounding check regression → a zero-hit result looked identical to "genuinely absent," so a silent no-op was free. Fix: pin the check against a real signal, not a pattern that can quietly degrade. Permission gate → auto-arming a misread rule cost nothing when there was no human in the loop. Fix: nothing gets armed without explicit approval. Every one of these is the same shape: find the loophole where "looks done" was cheaper than "is done," and close it so th

A 2023 HotOS paper by Sanjay Ghemawat (MapReduce/Bigtable co-author) and Amin Vahdat (Google Fellow) got repackaged by tech media as "microservices are dead." It said no such thing. Three years later, the misreading has traveled further than the paper itself. This post does three things: reconstructs what the paper actually claims, maps its three structural gaps, and introduces a variable the authors couldn't have predicted — AI code generation — which, I'll argue, undermines the paper's central solution more than any of those gaps. The AI section uses my own open-source project ReqForge as evidence. Flagging the conflict of interest up front: this isn't neutral analysis, it's a design rationale. Which is exactly why it's more honest than a hypothetical example. What the paper actually said The paper is Towards Modern Development of Cloud Applications (HotOS '23, 8 pages). Its core claim in one sentence: The fundamental problem with microservices is that they bind the logical boundary to the physical boundary. You let "how the code is organized" dictate "how the code is deployed" — two questions that should never have been welded together. From that claim, the paper proposes a three-layer solution: Logical monolith — developers write a cleanly modularized monolith; deployment is someone else's problem. Automated runtime — a smart platform that decides at runtime whether components should be merged or split, based on load. Atomic deployment — all components on a request path share one consistent version, avoiding half-old/half-new. Prototype numbers: 15× lower latency, 9× lower cost. That's it. The paper never says "microservices are wrong," never says "everyone should go back to monoliths," and gives no implementable plan. It's a vision paper — written to provoke discussion at a workshop, not an engineering whitepaper. A ruler Before dissecting it, here's a ruler you can apply to any architectural claim (this is a common framing in the engineering literature — you'r

From order, chaos. From courage, fear. From strength, weakness. — The 36 Stratagems, "Make a Sound...

I think AI is still being underestimated. I do not think people fully understand the scale of the shift that is already underway. In my view, this is not only about better chatbots or faster content creation. This is about a force that can reshape jobs, power, economics, thinking, and even the meaning of usefulness in society I predict that within the next few years, the world will move into a period where imagination itself starts to fail us. I believe there is a point ahead where the rate of AI progress becomes so steep that ordinary forecasting breaks down. When that happens, the biggest risk will not only be the intelligence of the systems we build, but the lack of maturity, policy, and collective wisdom around how human beings choose to use them . I Believe AI Is Underhyped I think AI is the most underhyped technology in human history. Most people reduce it to a conversation about job loss, but I believe job loss is only one small visible symptom of a much larger civilizational shift. The real issue is that we are building systems that may outthink humans in more and more domains while our institutions still behave as if this is a normal software wave . When I say AI is underhyped, I mean that society is emotionally behind the curve. People react with hype, awe, or fear, but very few people seem prepared to ask what happens when intelligence becomes massively scalable, cheap, and unevenly controlled. I think that gap between capability and preparedness will define the next phase of history . I Predict AGI Changes the Equation I believe that by around 2030 or shortly after, AI could reach a level that starts to resemble artificial general intelligence as I define it. For me, that means a system that shows expert level competence across many domains and can coordinate knowledge across disciplines instead of operating in one narrow silo at a time. Once intelligence works like that at scale, I think the normal assumptions people use about work, competition, and exp

I think AI is still being underestimated. I do not think people fully understand the scale of the shift that is already underway. In my view, this is not only about better chatbots or faster content creation. This is about a force that can reshape jobs, power, economics, thinking, and even the meaning of usefulness in society I predict that within the next few years, the world will move into a period where imagination itself starts to fail us. I believe there is a point ahead where the rate of AI progress becomes so steep that ordinary forecasting breaks down. When that happens, the biggest risk will not only be the intelligence of the systems we build, but the lack of maturity, policy, and collective wisdom around how human beings choose to use them . I Believe AI Is Underhyped I think AI is the most underhyped technology in human history. Most people reduce it to a conversation about job loss, but I believe job loss is only one small visible symptom of a much larger civilizational shift. The real issue is that we are building systems that may outthink humans in more and more domains while our institutions still behave as if this is a normal software wave . When I say AI is underhyped, I mean that society is emotionally behind the curve. People react with hype, awe, or fear, but very few people seem prepared to ask what happens when intelligence becomes massively scalable, cheap, and unevenly controlled. I think that gap between capability and preparedness will define the next phase of history . I Predict AGI Changes the Equation I believe that by around 2030 or shortly after, AI could reach a level that starts to resemble artificial general intelligence as I define it. For me, that means a system that shows expert level competence across many domains and can coordinate knowledge across disciplines instead of operating in one narrow silo at a time. Once intelligence works like that at scale, I think the normal assumptions people use about work, competition, and exp

Mnemo AI: Building an AI That Never Forgets You The Problem Every night, millions of people go to sleep feeling lost and forgotten. Today's AI tools are stateless—they forget you the moment you close the tab. Your struggles disappear. Your goals vanish. Your growth is invisible. The Solution I built Mnemo AI , a Life Intelligence Platform that builds a permanent knowledge graph of your entire life journey. It remembers everything you share—your name, your pet's name, your goals, your journal entries, and your emotions. My 7-Day Hackathon Journey I built Mnemo AI solo in 7 days. Every day was a challenge, but I never gave up. Day 1-2: Setup Flask + Cognee integration. Hit my first roadblock with async event loops on Windows. Day 3-4: Built the chat interface and memory recall. Fixed the "cat's name" bug. Day 5-6: Added journal, insights, timeline. Integrated Groq LLM. Day 7: Polished UI, added dark mode, voice input, and keyboard shortcuts. The Hardest Moment: Getting Cognee to work on Render's free tier. After hours of debugging, I learned that Cognee Cloud requires proper authentication setup. The Proudest Moment: Fixing the "cat's name" bug and seeing "Whiskers!" instead of "Your name is Priya!" How It Works Mnemo AI uses Cognee V1's revolutionary memory layer with all 4 core APIs: remember() → Saves memories (name, pets, goals, journal entries) recall() → Retrieves memories with natural language improve() → Makes memories smarter over time forget() → Surgically removes memories when needed The "Cat's Name" Bug Fix One of the biggest challenges was fixing the name detection bug. The app incorrectly matched any query containing the word "name", so "What's my cat's name?" would return the user's name! The Fix: I implemented regex-based intent detection that distinguishes between "my name" and "cat's name": def is_user_name_query ( q ): patterns = [ r " ^what( ' ?s| is)? my name\??$ " , r " ^who am i\??$ " , r " ^what do you call me\??$ " , ] return any ( re . match

I reopened an old project and found a working authentication implementation. What I could not find was the reason it looked that way. The commits showed the final code, but not: Why one approach had been chosen Which fixes had already failed What the coding agent warned me about Which tasks had been postponed The answers were scattered across a ChatGPT thread, a Codex session, and a terminal that no longer existed. There was another layer to it. I don't stick to one agent. I move between Codex, Claude Code, Cursor, and plain ChatGPT threads — sometimes because one tool genuinely fits the task better, more often because I simply run out of credits on one and switch to another mid-task. Every time that happened, the new agent started from zero. It had no idea what the previous one had already tried, decided, or ruled out. I either re-explained everything from memory, or let the new agent guess and re-discover things the old one already knew. This is not only a documentation problem. It is a structural problem in AI-assisted development. We use several tools to produce one project, but every tool keeps a separate, temporary memory. That experience became ContextVault. First: what is ContextVault? ContextVault is an open-source, local-first memory layer for AI work. It preserves useful context from browser LLM conversations, terminals, and coding-agent sessions, then makes that context searchable and reusable in later sessions. Think of the distinction this way: Git: what changed in the code? ContextVault: why did we change it, what failed, and what should happen next? The trigger for building it was specifically the agent-switching problem: whenever one agent ran out of credits or hit a limit, I needed the next one to pick up exactly where the last one left off, instead of restarting the investigation. ContextVault has three user-facing surfaces: Browser Capture — a Chrome extension that stores supported LLM conversations locally and exports Markdown or ZIP. Vault Term

📖 Read the full version with charts and embedded sources on ComputeLeap → You can now buy a walking, flipping, kung-fu-kicking humanoid robot on AliExpress for $4,900 — less than a used Honda Civic, less than a semester of community college, less than what most people spend on a couch-and-TV combo. Unitree's R1 AIR shipped its first global batch in April, and it represents something the robotics industry has been promising and failing to deliver for decades: a humanoid robot that a normal person can actually afford. But here's what the breathless headlines won't tell you: price is falling faster than capability. The gap between what this robot costs and what it can actually do is where the hype lives — and understanding that gap is the difference between seeing a revolution and seeing a very expensive toy. The Number That Matters The Unitree R1 AIR stands 4 feet tall, weighs 55 pounds, and packs 20 degrees of freedom into a bipedal frame that can run, do cartwheels, throw punches, and execute spin kicks . At CES 2026, Unitree's booth stopped traffic with R1s replicating Bruce Lee sequences, Michael Jackson dance moves, and Mike Tyson combinations. The base R1 AIR ships with a monocular camera, 8-core CPU, and onboard AI for voice and image recognition. For $1,000 more, the standard R1 at $5,900 adds six more degrees of freedom (26 total), binocular depth perception, waist articulation, and head movement. Both come with hot-swappable batteries — about an hour of runtime per charge. To put the price in context: Figure AI and Tesla each shipped roughly 150 humanoid units in 2025. Unitree shipped 5,500 . That's not a typo — Unitree alone outshipped every Western humanoid manufacturer combined by a factor of 20x. The R1's $4,900 price point isn't an outlier. It's the leading edge of a Chinese manufacturing tidal wave. The Raspberry Pi Parallel — and Its Limits When the Raspberry Pi launched in 2012 at $35, it didn't replace laptops. It didn't become the computer most peo

In the field guide I covered what an AGENTS.md is and what belongs in it. This is the hands-on follow-up: we'll build a complete AGENTS.md for a real project, one section at a time, then point an AI coding agent at it and watch the difference it makes. By the end you'll have a working file — and you'll have seen it pay off. New to AGENTS.md? It's a single Markdown file at the root of your repo that tells AI coding agents how to work in it — build steps, tests, conventions, guardrails. The "why" behind each section is in the field guide . The project we'll use We'll write the AGENTS.md for a small but real service: a URL shortener API in Python — FastAPI, SQLite, pytest. A couple of endpoints, a thin data layer, a test suite. Follow along with this, or swap in your own repo — the steps are identical. Its shape: linkshort/ app/ main.py # FastAPI routes db.py # SQLite access models.py # Pydantic models migrations/ # generated SQL — not hand-edited tests/ requirements.txt Step 0 — Start with an empty file At the repo root: touch AGENTS.md That's the whole step. We'll fill it in one section at a time, building toward a file an agent can read in thirty seconds. Step 1 — Orientation: one line Tell the agent what it's looking at. Add: # AGENTS.md A URL shortener API in Python — FastAPI, SQLite, pytest. One sentence sets the agent's priors: it knows the language, framework, and storage before it reads a single line of code. Step 2 — Setup and run The agent can't help if it can't start the project. Add the real, copy-pasteable commands: ## Setup python -m venv .venv && source .venv/bin/activate pip install -r requirements.txt ## Run uvicorn app.main:app --reload # http://localhost:8000 Use the commands that actually work in your repo — no placeholders. Step 3 — Tests: the agent's feedback loop This is the most important section, because tests are how the agent checks its own work. Add: ## Test — all must pass before a change is done pytest ruff check . mypy app Now the agent