Why We're Building AgenticLoops — Code First, No Hype
If you're a software engineer trying to understand what's actually changed in AI engineering without wading through the hype, this is for you.
We’ve both been building software for a long time: distributed systems, data platforms, internal tooling, microservices platforms. The usual stuff. And honestly? Right now is one of the most genuinely exciting moments we’ve experienced in this industry. AI agents are actively changing how software gets built, and the full impact is still hard to measure. Andrej Karpathy’s recent talk on this is the clearest articulation of this shift we’ve come across. What is clear is that this isn’t going away, and waiting for things to stabilise is not a safe strategy. Every month spent on the sidelines is a month other engineers are building intuition you don’t have yet.
But with a wave this big comes a lot of noise. The hype moves fast, and it can make it hard to see clearly: what’s actually changed, what’s just a polished demo, what works in production versus what only works on stage. We were asking ourselves those same questions. What we found was a lot of conflicting opinions. The only way we actually understood any of it was by building it ourselves.
AgenticLoops is where the excitement meets the engineering.
What Is AgenticLoops?
AgenticLoops is a community for engineers, by engineers. Not a course platform. Not a newsletter full of AI news summaries. Not another community where people share prompts and call it “AI development.”
It’s a place for software and platform engineers — whether you’ve been building production systems for years or you’re still working your way there — to get genuinely useful, technically honest content about what it takes to build reliable agentic AI applications. Not the toy kind. The kind where production readiness, failure handling, and cost management are first-class concerns from day one — not afterthoughts you bolt on when things break in front of real users.
If you have a software engineering or platform background and you’ve been trying to catch up on what’s actually happened in AI Agentic Software Engineering over the last two years — that’s exactly who we built this for.
This is NOT a community for ML engineers doing LLM research. We are not here to discuss training runs, fine-tuning strategies, or whether attention is all you need. That’s important work, done by people far more qualified than us. Our focus is narrower and more specific: building production-grade agentic applications that actually work.
What We Actually Believe
Before we tell you what we’re building, it’s worth being upfront about the values underneath it. These aren’t marketing copy — they’re the lens through which we evaluate every piece of content we put out.
01 — First principles over frameworks
Frameworks come and go. LangChain goes through a major paradigm shift every six months. New agent frameworks launch every other week. But the underlying constraints — context windows, statelessness, hallucination, token costs, latency — those don’t change. If you understand why a context window matters, you can work with any framework. If you only know how to set max_tokens in LangChain, you’re stuck the moment something breaks or something better comes along.
We’ll teach frameworks. But only after you’ve built the same thing yourself from scratch.
02 — Design for non-determinism
Here’s the thing that trips up experienced engineers the most when they first build agents: you cannot assert output == expected. Traditional software gives you guarantees — same input, same output, every time. LLMs don’t. Given the same prompt, the same model, the same temperature setting, you can still get meaningfully different responses.
That’s not a bug you fix. It’s a constraint you architect around. The engineers who build reliable agents aren’t the ones who found a trick to make the LLM behave — they’re the ones who designed their systems assuming it won’t, and built accordingly.
03 — Master the trade-offs
Writing code has never been easier. Drop a Cursor tab open, describe what you want, get working code in seconds. That part is genuinely remarkable and we’re not going to pretend otherwise.
But making the right architectural trade-off has never been harder. Autonomy vs. control. Flexibility vs. predictability. Speed vs. safety. Multi-agent orchestration vs. a single well-prompted call. How much context to keep vs. how much to summarise. These decisions require a deep understanding of what’s actually happening underneath — and the consequences of getting them wrong in production are real.
04 — Learn by building
We are deeply skeptical of content that teaches AI engineering without running code. You can read a thousand blog posts about the ReAct pattern and still have no idea how to implement it, debug it when it loops, or evaluate whether it’s actually working. The only way to develop real intuition for this stuff is to build it yourself, watch it break, and figure out why.
Everything we publish will have runnable code attached. Reference implementations. Battle-tested patterns. The actual mechanics, not the abstraction.
Our Approach: Code First, No Hype
The two labels on our homepage — code first and no hype — aren’t aesthetic choices. They’re constraints we put on ourselves.
Every concept we explain has to be demonstrable in a simple script that you can run on your machine, inspect line by line, and modify to test your understanding. No black boxes. No “just trust the framework.” If we can’t explain something with runnable code, we don’t ship it until we can.
Our main repository, agentic-ai-engineering, is the best example of what this looks like in practice. It’s organized as a progressive curriculum — six modules, each building on the last — but every lesson is its own self-contained, runnable Python script. You don’t need to install a monolithic environment or watch a video. Clone the repo, navigate to the lesson, run it, break it, change it.
The curriculum starts where it should: first principles. A single API call. Then conversation history. Then tool use. Then the full agent loop — and by that point you’ve built something genuinely useful: a working coding agent that reads files, runs bash commands, and reasons through multi-step tasks autonomously. Clear structure, no framework, nothing hidden. From there it progressively layers on the architectural patterns that show up in real production systems, the advanced techniques you hit the moment prototypes leave the laptop, an honest framework comparison where you build the same agent nine different ways so you can judge the trade-offs yourself, and finally the parts most tutorials skip entirely — testing non-deterministic systems, tracing and debugging agent loops, and getting from “works on my machine” to “runs reliably at scale.”
Every lesson is independently runnable and designed so you can experiment freely — tweak a parameter, swap a tool, break the loop intentionally — because that’s how engineering intuition actually forms.
What You Get From Being Here
If you’re a software engineer who’s been peripherally watching the AI agent space and feeling like you’re behind — you’re not. The fundamentals are learnable in weeks, not years. You already have the systems thinking, the debugging instincts, the production intuition. What you need is a reliable map of the new terrain.
That’s what we’re trying to be. Concretely:
Free, open-source code you can clone, run, and modify. Not demos. Not notebooks you can’t easily adapt. Real, runnable Python scripts, organized so you can find exactly what you need.
Engineering-first explanations of how these systems actually work. Context windows as a constraint to architect around. Statelessness as a design consideration. Hallucination as a failure mode to mitigate, not ignore.
Pattern-level thinking that transfers across frameworks and models. We’re not teaching you how to use a specific tool — we’re teaching you how to think about the problem.
Honest trade-off analysis. There’s no “best” agent framework. There are trade-offs, and they depend on your constraints. We’ll give you the actual comparison, not a sponsored take.
And as the space moves — which it will, constantly — we’ll move with it. New patterns, new models, new operational challenges. We’ll stay current and we’ll tell you when something has genuinely changed and why.
What’s Coming Next
The curriculum you can access right now covers foundations and patterns — the core building blocks. But we have three more tracks in the works that get into territory most content doesn’t touch:
Agentic Apps Internals: Reverse-engineering popular AI agents — system prompts, tool architectures, implementation decisions. When you actually look at how Claude Code or Cursor or Devin structures its tools and context, you learn more in an afternoon than you’d learn from a week of tutorial content. We want to make that kind of analysis accessible and systematic.
Agentic AI Patterns: A dedicated deep-dive into design patterns: ReAct, multi-agent orchestration, memory management, structured output strategies. Less “here’s how to use tool X” and more “here’s the pattern, here’s when you’d reach for it, here’s what it costs you.”
Agentic Platform Engineering: This one’s for the platform and infrastructure engineers in the room. How do you build an internal AI platform? What does orchestration look like at scale? How do you handle observability, cost attribution, rate limiting, security, when you’re running dozens of agents across an organization? These are real questions that platform teams are wrestling with right now, and there’s almost nothing useful written about them.
A Final Note
We’re not building this because we think we know everything about AI engineering. We’re building it because we’re learning fast, the space is moving fast, and we think the best way to learn is to teach — and to do it with people who take the craft seriously.
If you’ve made it this far, you’re probably our kind of engineer. Skeptical of magic. Interested in what’s actually happening under the hood. Willing to run the code rather than just read about it.
Follow along. Join the discussions. Break the code and tell us when we’ve got something wrong.
The agent loop has started.
— Alex & Vishal
AgenticLoops is free and open source. All code lives on GitHub. Subscribe here to get notified when new modules, patterns, and analysis drop.
Start here: agentic-ai-engineering on GitHub. If you want to jump straight in, Module 01, Lesson 01 is a single Python script. Clone the repo, run it, and you’ll have made your first LLM call with full token tracking in under five minutes.