An essay, a history, and a field guide for the people building alongside me.
Abstract
This is part history, part argument, part manual. It tells the story of how Chasing Jarvis came to exist, why a serial entrepreneur with thirty years of building behind him decided the most urgent thing he could teach was not a technology but a posture, and how anyone — student or not, technical or not — can follow the same path using the same free, open tools my students use. The thesis underneath all of it is a single sentence I keep returning to: the gap between an idea and a shipped product is no longer technical. It is contextual. What follows is the case for that sentence, and the on-ramp for acting on it.
We are learning to build and ship real digital products using AI coding agents. The gap between idea and shipped product is no longer technical, it is contextual.
— The premise of Chasing Jarvis
Part I — A Confession Disguised as a Flex
Let me start where I started a recent year-in-review, because it is the most honest doorway into this whole story. People post their GitHub contribution graph as a flex. I want to post mine as a confession. Twelve months, 1,278 contributions. Ninety-eight percent commits. To a developer, that profile reads in about a second: a solo builder who ships and who works alone. Both true. I work alone with agents.
I am not going to pretend the green squares are modest, because they are not. But I am also not going to pretend they are the story, because they are not. Anyone can farm green squares. The question that matters is what sits underneath them. Underneath mine are four shipping products built in roughly two quarters: ARIA, a full-stack real-time AI avatar platform of some 17,000 lines, built across more than 300 agent sessions; The Curator, an open-source local-first knowledge system; the MountVacation MCP, one of the first open-source MCP servers for tourism; and Organisation of Tomorrow, a framework for AI-augmented companies. Alongside them: Lumina AI, a SaaS I built in thirty days on a rained-out ski trip in the Dolomites, and Moj AI, a multi-agent platform for Slovenia’s building legislation.
Here is the part the graph quietly hides. None of this was clean, heroic progress. It was conflicting commits. It was an agent deploying to the wrong production project entirely. It was a genuinely embarrassing bug where my own test infrastructure was silently writing into real user knowledge folders. The darkest-green Saturdays are not triumph. They are debugging. I tell my students this on day one, because the loudest voices online skip it: it does not work out of the box. You have to learn the basics — what a database is for, what an API does, why deployment is its own discipline. But once you have that literacy, building is now perhaps a thousand times easier for a non-developer than it was two years ago.
I am not an engineer by training. I am a serial entrepreneur — across ventures like Lumina AI, 4thTech, Immu3, PollinationX, Block Labs, Online Guerrilla and others — who spent three decades watching the same painful pattern repeat: you have an idea, then you spend six months of salaries and meetings to reach an MVP, and at the end, the thing you got is frequently not the thing you imagined. The most painful part was never really the money. It was the waiting. The full story of that year, with the receipts, lives in A Year in the Review.
Five traditional developers, six to twelve months. One founder with agents, six weeks. Same target. The difference is not a percentage. It is an order of magnitude.
— On the ARIA avatar platform — the client did the counterfactual maths
That collapse in the cost of trying is the whole reason this course exists. When the cost of testing an idea falls from a payroll and half a year to a weekend and a few hundred dollars in credits, the number of ideas a single person can test in a year explodes, and so does the question of who gets to be a builder at all. Chasing Jarvis is my attempt to answer that question for the people I teach.
Part II — The Why: VUCA Meets the Centaur
Chasing Jarvis did not begin as my idea. It began as a request. Dražen Kapusta, COTRUGLI‘s principal, came to me with a problem framed as a question: in a world moving this fast, what does the next level of education for leaders actually look like? Not another AI-literacy webinar. Something that changes how a founder, a manager, a CEO actually works the next morning.
The world for which the course was built
We live in a VUCA world — volatile, uncertain, complex, ambiguous — and my colleagues at COTRUGLI describe the present moment with a sharper lens still: the NEO era, where value is Networked, growth is Exponential, and success comes from Orchestration rather than hierarchical control. The analogy Dražen uses is the business leader of 1850 watching steam engines, railways, and telegraph lines rewrite every rule they knew. Some adapted. Most did not. “The NEO era is not coming. It is here. The question is whether you will lead the transformation or spend the next decade trying to catch up.”
For a leader, this is not an abstraction. There has always been a structural bottleneck between vision and execution. The person who set direction was frequently not the person who understood, in fine detail, how the product was actually built. They led a technical team or a developer-CEO, but the build itself stayed opaque to them. Decisions about what was possible, what was cheap, what was slow, all of it was mediated by someone else’s understanding. With modern coding agents and agent harnesses, that bottleneck is dissolving. The ceiling is no longer “can you code.” It is how well you can specify, structure, and supply context.
The Centaur model — the thesis that anchors everything
If there is one idea I return to in every cohort, it is the Centaur model. The human contributes spec, taste, judgement, and the parts of the work that depend on context, the model has never seen. The AI contributes to implementation at speed. Neither is sufficient alone. This is not motivational framing; it has roughly thirty years of literature behind it, and the 2025–2026 evidence converges hard:
• Harvard Business School — The Cybernetic Teammate (Dell’Acqua et al., 2025). A controlled field experiment with Procter & Gamble (n=776) found that individuals working with AI matched the performance of two-person teams without AI, and that AI broke down silos between R&D and commercial roles.
• Karpathy — Software 3.0 (Sequoia AI Ascent, 2026). The cleanest framing of the new division of labour: spec is human, implementation is AI, review is human. Agents are “intern entities” that need taste and judgement supplied to them.
• DORA 2025, MIT NANDA, Microsoft Frontier Firm 2025 all land on the same finding: the highest-performing teams are neither AI-sceptics nor AI-maximalists. They are the ones who redesigned their workflows around the centaur pattern.
The honest version of the thesis matters too. “Centaur” gets watered down when it is used as a slogan to keep humans in roles where they no longer add value, or as a fig leaf for full automation. The discipline is to be specific about where human judgment actually compounds. I unpack the founding version of this argument in my article Are We Becoming Obsolete or Finally Free?, and the practical three-stance version — instruction-follower, collaborator, orchestrator — in Three Philosophies, One Goal.
One of my online Chasing Jarvis participants put the human side of this better than I could. It is worth reading in full, it is the Centaur model felt rather than argued:
Kyomuhendo Milliam (CTO, Asili Education · Vanguard MBA) on what to actually do with the hours AI gives back.
The extra hours are not a reward. They are raw material for becoming a player-coach. The player-coach is not built in moments of high visibility. It is built in the quiet investment between them.
— Kyomuhendo Milliam, reflecting on a Chasing Jarvis session
That is the why, compressed: VUCA makes the old pace untenable, the Centaur model makes a single prepared human extraordinarily productive, and the freed-up margin is only valuable if you redirect it toward going deeper — on your craft, on your team, on the next idea — rather than letting it evaporate.
Part III — A Short History of the Course
Chasing Jarvis takes its name from the arc it teaches: the evolution from passive AI assistants toward autonomous, capable digital workers, the fictional “Jarvis” made ordinary. It has now run in several forms.
The online cohort — roughly 150 builders, largely across Africa
The first full edition ran online and gathered close to 150 participants, drawn predominantly from across multiple African countries, and was partly supported and promoted by the UN. It followed the complete five-module-plus-pre-module structure over distributed Zoom sessions. The energy from that cohort still shows up in my inbox and my Telegram channel.
Messages from the online cohort — Boniphace, Diane, and Kaouther — after a live session.
The short introductory sessions
Alongside the full program, I run condensed, up-to-two-hour introductory sessions — lighter-touch entry points and executive tasters that carry the same core message without the full build.
Belgrade 2026 — two days, two cohorts, real MVPs
The most refined edition to date was a two-day live intensive in Belgrade for the Vanguard MBA, across two cohorts and different generations. The venue mattered: the Tolstoy Members Club, originally the ambassadors’ club of the former Yugoslavia, a room built for diplomacy, dark wood and high ceilings, deliberately preserved. There is something fitting about teaching the next generation of AI builders in a room where the world’s diplomats once negotiated the future.
By the end of Day 2, every group had shipped something real with a live URL: factory-floor optimization tools, bank-regulation compliance dashboards, workflow automation systems, all built by business professionals, many of whom had never touched a developer tool two days earlier. That is the entire point of the course, demonstrated rather than promised.
Ana Romac (Sales Director, Iskon) on building her own app and touching the real possibilities of AI for the first time.
Petar Urdešić (Banking Operations Executive) — and my reply: intensive, because it is the only way to learn.
And from the COTRUGLI side, Snežana Ilić, who makes these events happen, captured the institutional read on it:
Snežana Ilić (Business Development Manager, COTRUGLI) on ideas becoming real solutions when expertise meets the right AI tools.
Part IV — The Manual: Follow Along, Module by Module
Here is where the life story becomes a practical guide. You do not need to be enrolled anywhere to walk this path. My students learn as much from my written field notes as from the lectures, so each module below points you to the articles that go deep and, crucially, to the three open-source tools you will actually use. Everything here is free or near-free. The only standing rule: learn the Lego bricks before the agents. Spend a week understanding what a database, an API, authentication, and deployment really are. You are not learning to code. You are learning enough to direct.
A note on structure. In the live program, these are five modules plus a pre-module, delivered in sequence. As a self-learner, you can treat them as five stages. One important change in the current design: context engineering is no longer parked in Module 4. Students now meet it in simple form from Module 1 and deepen it throughout. Module 4 becomes the place where they produce the actual documentation bundle that powers their build.
Module 1 — Understanding LLMs (so you stop treating them as magic)
Why it matters. You cannot direct what you do not understand. The goal here is not to turn you into an ML researcher; it is to dissolve the black box just enough that your tool choices and your prompts stop being superstition. The single most useful mental model is this: an LLM is a sophisticated autocomplete trained on vast human knowledge, predicting the next most-likely token one step at a time. “Paris” follows “The capital of France is…” because the probabilities say so, not because the model knows France.
What to actually learn: token prediction, where a token is roughly three-quarters of a word; what a neural network is at a high level; scaling, and why bigger models are qualitatively different rather than merely bigger; and, most important for everything later, memory. The context window is short-term memory; markdown files, RAG, and a second brain are long-term memory. Modern context windows run from 128K to 2M-plus tokens, but the model does not truly remember anything you do not put back in front of it. The course compresses all of this into one line: Agents = LLMs + Context + Tools + Memory.
Read: Understanding Large Language Models: A Complete Manual — the complete non-technical foundation. Core hook: “LLMs complete patterns. They don’t understand. That distinction changes every workflow you build.”
Links:
github.com/talirezun/the-curator (MIT licence, runs locally, needs only a Gemini or Anthropic API key).
Module 2 — The Tooling, with one obsession: the agent harness
Why it matters. There is a whole zoo of AI tools, and most courses drown you in it. We do the opposite. We map the landscape quickly — frontier chat models (Claude, ChatGPT, Gemini, GLM, Kimi, DeepSeek), generative tools (Nano Banana Pro, Veo, ElevenLabs), research tools (NotebookLM), and local/sovereign options (LM Studio) — and then we focus almost entirely on the thing that actually determines your results: the agent harness.
The harness is everything that surrounds the coding agent so the model behind it can function: the tools layer, the memory layer, the instruction layer, the governance and verification layers. A capable model in a poor harness underperforms a modest model in an excellent one. So we go deep on a small set of harnesses rather than wide on many: Claude Code, opencode (free, open-source — my recommended starting point), Codex, and Augment Code for production codebases. We deliberately do not teach the sprawling no-code automation stacks; they add complexity without adding understanding.
Read, in order:
• Three Philosophies, One Goal — the gentlest entry: three cooking analogies for three ways of working with AI, ending on orchestration.
• From Writing Code to Directing Intelligence — five days inside an orchestration tool, and the moment directing replaced typing.
• Blueprint of a Frontier Coding Agent — the 12-component anatomy of a production harness. Core hook: “The harness is not infrastructure. It is not plumbing. It is the product.”
• Data Sovereignty in the AI Age — when and why to run models locally; read this before you touch LM Studio.
Links:
github.com/talirezun/conduit-agent (Apache 2.0).
Module 3 — AI Agents: from answering to acting
Why it matters. This is the conceptual heart of the course, the leap from using AI to orchestrating it. A chatbot answers a question. An agent runs a task across multiple steps, sources, and systems. My working definition: an AI agent is a large language model that achieves autonomy through tool connectivity — primarily via the Model Context Protocol — enabling goal-directed behaviour through autonomous execution loops. The loop to internalise is Perceive → Reason → Act → Observe → Iterate.
What to actually learn: the assistant-versus-agent distinction; the Model Context Protocol (MCP) as the open standard that connects agents to tools (the USB-C analogy — one protocol, any tool, eliminating the N×M integration problem); the master system message as the instruction layer that defines an agent’s behaviour and when it uses which tool; and the context window as a fuel gauge, around 80% the output degrades, and you write a handoff and start a clean session before the model starts contradicting itself.
Read:
• Understanding AI Agents: From Chatbots to Autonomous Digital Workers — the foundational explainer.
• The Agent Memory Problem, and Why It Matters — the four kinds of agent memory, the “context rot” problem, and why a compiled wiki beats stateless RAG for agents.
• Exploring Early Indicators of AGI in Coding Agents — what reasoning loops start to look like once agents get real tool access.
Module 4 — Context Engineering: the master skill, made practical
Why it matters. If there is a single skill this entire course exists to teach, it is this one. Prompt engineering is single-instruction crafting — like giving directions. Context engineering is building the complete information environment, like creating a workspace. The accuracy difference on complex tasks is not subtle: roughly 40–60% with prompting alone versus 85–95% with proper context. As I tell every cohort: one hour of context engineering beats ten hours of prompt refinement.
Context engineering is the delicate art and science of filling the context window with just the right information for the next step.
— Andrej Karpathy — the definition the course adopts
In the redesigned course, Module 4 is less a first encounter with the idea and more a production line. By now you have been doing simple context engineering since Module 1. Here you build the actual documentation bundle that will drive your MVP: a CONCEPT.md (market and concept research), an ARCHITECTURE.md (the technical structure), a BLUEPRINT.md / FEATURES.md (the feature specification), and a UI_UX.md (the user scenarios). Markdown is the lingua franca because both humans and agents read it perfectly, and because context is more than text — screenshots, sketches, and annotated UI all count.
Read:
• From Prompts to Precision: The Art & Science of Context Engineering — the 8,000-word foundation.
• Effective Context Engineering for AI Agents (Anthropic) — the engineering-side companion.
Module 5 — Build & Ship: context becomes a live URL
Why it matters. Everything converges into a deployed product. This is also where my three-phase build process — the method I use for every product I ship — becomes the spine of the work. I documented it fully in Context is the Code: The Complete Three-Phase Process, and it is worth stating here because it is, in a real sense, the point of Chasing Jarvis:
Phase 1 — Research, Design & Foundations. Before any code, you produce the context bundle from Module 4. Every hour here saves five later. This is where vision, architecture, and intent get written down in a form an agent can act on.
Phase 2 — The Build. You feed the bundle to a coding agent and enter the build loop: build → test → iterate. You watch the context window like a fuel gauge, write handoffs before it degrades, and use live-verification tools (a browser-driving MCP, for instance) so the agent can see what it is building and close the loop itself.
Phase 3 — Debug, Audit & Deploy. You scope real infrastructure, deploy (GitHub → a host such as Firebase or Cloudflare, often a free tier), and run a multi-model security and quality audit before you ship the live URL.
Crucially, context engineering is not Phase 1. It is the discipline that runs through all three phases — and above it sits harness engineering. That three-level stack (prompt → context → harness) is the through-line of the whole course.
Two tracks, by comfort level: Track A (beginner) uses Google AI Studio plus a free Gemini key and Firebase for hosting. Track B (production-ready) uses Claude Code, Antigravity, Augment Code, or opencode. Either way you finish with a working, shareable product.
Read:
· Context is the Code: The Complete Three-Phase Process for Building with AI Agents
· Two Words of Code: The Gap Between AI Agent Orchestration and Legacy Development
· I Build Auto Loops Before They Had a Name
· From Prototype to Pruduction: Building Lumina Platform in 30 days
Links:
github.com/talirezun/oot-framework — install it agent-assisted in 60–90 minutes.
Part V — Your Open-Source Toolkit
The three tools above are not demos. I build with them daily, they are fully documented, and they are free and open. Together, they map the same progression the course follows: build your memory, then your agent, then your organisation. If you take nothing else from this article, take these three repositories and the order in which to meet them.
All three include full user guides, so a reader outside any school or program can follow along end-to-end. If you find The Curator useful, a star on the repository genuinely helps the next non-developer find it.
Repos:
- https://github.com/talirezun/the-curator
- https://github.com/talirezun/conduit-agent
- https://github.com/talirezun/oot-framework
Closing: One Context Package Away
A few things I keep seeing prove true, cohort after cohort, and they are the truest summary of why I teach this:
• The technical barrier is almost always psychological, not real.
• The moment someone shares a live link they built themselves, something shifts permanently.
• Non-technical founders are not at a disadvantage — they are one context package away from shipping.
I have spent thirty years building technology, and I have never seen a transition this fast or this fundamental. The agents do not replace judgement; they amplify it. What has collapsed is the cost of trying, and when the cost of trying collapses, the question of who gets to build collapses with it. That is the opportunity Chasing Jarvis exists to hand you. Start with context. Build with discipline. Deploy with confidence. The green squares are just what that looks like over a year.
What stands out most is not the technology itself, but how quickly meaningful ideas can become real solutions when expertise meets the right AI tools.
— Snežana Ilić, COTRUGLI Business School
About the Author
Dr. Tali Režun is a Serial Entrepreneur, Business Developer, and Academic at the forefront of frontier technologies. As Vice Dean of Frontier Technologies at COTRUGLI Business School, he leads AI innovation initiatives and shapes MBA curricula for the next generation of technology leaders. With over 30 years of entrepreneurial experience — founding and scaling ventures including The Curator, Lumina AI, Moj AI, Block Labs, 4thTech, Immu3, PollinationX, and Online Guerrilla — he bridges cutting-edge research in AI and Web3 with practical business transformation. He writes field notes from real builds at From Lab to Life.
Find the work: talirezun.com · From Lab to Life (Substack) · Medium · LinkedIn · X · GitHub
Sources & Further Reading
1. Are We Becoming Obsolete or Finally Free?
2. Three Philosophies, One Goal: A Practitioner’s View
3. Understanding Large Language Models: A Complete Manual
4. From Prompts to Precision: The Art & Science of Context Engineering
5. Understanding AI Agents: From Chatbots to Autonomous Digital Workers
6. The Agent Memory Problem, and Why It Matters
7. Blueprint of a Frontier Coding Agent
8. From Writing Code to Directing Intelligence
9. Context is the Code: The Complete Three-Phase Process
10. Behind the Curtain: The Three-Phase Process I Use to Build Every AI-Coded Product
11. From Prototype to Production: Building an AI Widget Platform in 30 Days
12.From English to Code: Building Production SaaS with Claude Desktop
13. Data Sovereignty in the AI Age: Building Your Own Private ChatGPT
14.Exploring Early Indicators of AGI in Coding Agents
15. Building Knowledge Immortality Through the Second Brain
16.Building the Organization of Tomorrow
17. Law = Code: Can AI Finally Democratise the World’s Most Exclusive Algorithm?
Selected research underpinning the Centaur thesis
– Dell’Acqua, F. et al. (2025). The Cybernetic Teammate. Harvard Business School Working Paper 25-043 (P&G field experiment, n=776).
– Karpathy, A. (2026). Software 3.0. Sequoia AI Ascent.
– Google / DORA (2025). State of DevOps / DORA Report 2025.
– Microsoft (2025). Work Trend Index 2025: The Frontier Firm.
– MIT NANDA (2025). The GenAI Divide.
Disclaimer. Published for research and educational purposes. The author has not been compensated or sponsored by any company, platform, or tool referenced. Self-reported figures (commit counts, timelines, line counts) are drawn from the author’s own project records at the time of writing; live repository figures change over time. The AI agent ecosystem evolves rapidly — verify current capabilities with primary sources.