Abstract. This is a year-in-review, written as a research note and told as a story. The headline figure is 1,278 GitHub contributions in twelve months. The real subject is productivity: what a single founder can now build alone with AI coding agents, measured against three decades of doing the same work with hired and partnered development teams. I argue that the most under-reported event of the current cycle is not any single model release. It is the democratisation of software building. The bottleneck has moved from code to context and vision, and that shift is good news for every founder who has ever waited six months and a payroll for an MVP that arrived wrong.
1. A Confession Disguised as a Flex
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, two percent pull requests, almost no issues and almost no code reviews. To a developer, that profile reads in about one second: this is 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 that either. Anyone can farm green squares. The question that actually matters is what sits underneath them.
So before we go anywhere else, let me put the receipts on the table. Four projects account for roughly 660 of those commits, and every one of them shipped or is shipping:
Six hundred and sixty commits across four distinct, named, shipping products in about two quarters. That is not activity. That is a portfolio. And here is the part the graph quietly hides, the part I actually want to confess: this was not twelve months of clean, heroic progress. It was conflicting commits. It was agents 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 in that graph are not triumph. They are debugging. Keep that in mind every time someone shows you a beautiful contribution heatmap, including mine.
The number is not the argument. The composition is. A near-pure commit profile across four shipping products is what a founder building alone with agents looks like. The graph is the receipt, not the thesis.
2. The Thing People Are Not Getting
Let me state the thesis of this entire piece in one sentence, because everything else is evidence for it: software building has been democratised, and most people have not internalised what that means yet.
It does not work out of the box. I want to be honest about that, because the loudest voices online tend to skip it. You have to invest time! You have to learn the basics, the Lego bricks of how a piece of software is actually assembled, what a database is for, what an API does, what authentication means, why deployment is its own discipline. But once you have that basic literacy, I can tell you from experience that building applications is now perhaps a thousand times easier for a non-developer than it was even two years ago. Maybe it came naturally to me because I have spent my life around developers and did plenty of basic coding myself. But I am now convinced that anyone with a basic feel for technology, and a genuine love for productive work at a computer, can master these skills. This is not a gift reserved for engineers.
And the consequence for founders is the part that should make people sit up. The most painful thing about building used to be the money, but it was not really the money. It was the waiting. You had an idea. Then you spent six months of salaries, six months of meetings, six months of thinking, just to reach an MVP. And at the end of all of it, the thing you got was frequently not the thing you imagined. In a world that now moves at light speed, that model is not merely expensive. It is broken. Time to MVP used to be measured in quarters. For me, today, it is measured in an overnighter.
Before AI agents, the cost of testing an idea was a payroll and half a year. Now it is a weekend and a few hundred dollars in credits. That single change rewrites what it means to be a founder.
3. How I Got Here: Thirty Years, Briefly
I am an entrepreneur first. An organic one. I went through a great deal of formal education, the Executive MBA, the business doctorate, but I did almost all of it during my most intense entrepreneurial years. First I was a founder. Then I waded into academic waters and finished the doctorate. And now I have the honour of serving as Vice Dean of Frontier Technologies at COTRUGLI, one of the leading, fully AI-oriented business schools, trying to translate what I have actually lived into something my students can use. I treat that as a privilege. But the founder never left. I am always developing ideas and deploying products, and what AI coding agents have really given me is the freedom to test my own ideas without first raising the drawbridge of a development budget.
The technologist years
I have always been a technical person. A technologist, if I am allowed the word. I was building my own hardware, my own computers, at sixteen. I started getting my hands dirty with code in the early 2000s, HTML and CSS, because I was building websites for my own businesses to ride the wave of search engine optimisation. I was good at it. For roughly a decade, the golden years, I could sell more or less anything I wanted, because whatever I optimised landed first on Google. I have always had some luck in spotting a technological opening a little before the crowd does, and SEO was a beautiful shortcut to the web. Then I fell down the WordPress rabbit hole and never fully climbed out. WordPress mattered to me for a reason that will sound familiar by the end of this article: it let me power my own businesses, new and old, without waiting for developers. A whole website for a new idea, sometimes a simple app, standing up in a couple of days, by my own hand. If that sentence sounds like a small thing, it is because you have not yet felt how rare it used to be.
The blockchain years
In 2016 I discovered blockchain, and the decentralisation and permissionless thesis simply overwhelmed me. I am still a believer, and recent history has only sharpened the conviction. When we make ourselves dependent on centralised platforms and centralised services, the platform can be taken away from us overnight. We have just watched exactly that happen with the suspension of a deployed frontier model Fable, the first government-mandated takedown of its kind. As a European who suddenly could not access it, I did not read about the lesson. I lived it. That is precisely why I believe local models will become enormous: on our phones, on our laptops, everywhere. You cannot power the intelligence needs of all of humanity through centralised platforms alone. We will keep the big clouds, of course, but we will increasingly run capable models on our own machines, and I consider that a genuinely important step toward the decentralisation of intelligence and permissionless access to it. People should have something close to equal access to intelligence. The harness around it must be built with real caution, because nobody wants frontier capability in unstable hands, but that is a hard philosophical question I will leave for another article.
With my partners and my team I started several blockchain ventures that still run today. Our focus was wallet-to-wallet, encrypted, permissionless on-chain communication, where one message equals one blockchain transaction. I am convinced this is foundational technology for future agentic communication on-chain, and that it will find its proper fit. We also built and deployed PollinationX, a decentralised storage service that lets people access decentralised storage through NFTs, where a single NFT can represent one, five, or fifty gigabytes of storage on a decentralised network. Again: quietly foundational for a future in which agents act and store on our behalf.
Documentation: the on-chain communication protocol at wiki.4thtech.io, and the decentralised storage service at wiki.pollinationx.io.
Those years also taught me something I only fully understood later. In blockchain you live or die by documentation. I spent months polishing, technical documentation, user guides, terms and conditions, pitch decks, elevator decks, every block of text on every web page, hunting for the right flow of words. Anyone who has done it knows the weight of it. We built our main Next.js website for the on-chain protocol in roughly half a year. Half a year. With AI today, that same work is not twice as fast or five times as fast. It is something like a hundred to a thousand times faster. Spinning up a polished product page is now an afternoon. I mention this not to complain about the past but because it is the cleanest before-and-after measurement I own.
4. Two Years Learning to Direct Intelligence
I started researching and working with the first real coding agents in early 2024. Sonnet 3.5 was, in my experience, the first model that could handle genuinely decent coding. That ability arrived as a surprise, even to the labs: an emergent behaviour that nobody had explicitly planned, surfacing once language models crossed a certain scale. Coding was one of the abilities that simply appeared. I did not wait for tooling to mature. I built my own crude coding agents around my own needs, starting inside VS Code with the Cline extension, feeding it master prompts and instructions to coax out early results.
It was not until the last quarter of 2024, when Anthropic released the Model Context Protocol, that things clicked. I remember building my first proper MCP-driven agent around the end of December 2024, wiring in the early servers: Context7, sequential-thinking, GitHub, a handful of others. Claude Code arrived in January 2025 and I was an early beta tester, but at that point it was simply too expensive for me, so I built my working agent inside the Claude desktop app instead, because it ran on a flat subscription. That was the first time I got results I would call genuinely good. Then, in the summer of 2025, I started using Augment Code, and the ground shifted under me. Managing context was still a nightmare because the windows were small, but that pain is exactly what forced me to master context engineering, the single discipline I still use every single day.
The real breakthrough, for me, came with the Opus 4.x line and the million-token GPT models. A one-million-token context window changes the game: you can run a large model as an auditor or a debugger across a serious codebase without it losing the thread. With context engineering as a habit and the frontier lines as the engine, I reached a quiet but enormous milestone. I can now build essentially whatever I want, even in domains I have never touched, as long as I follow my own three-phase process. I documented that process in detail across several articles, and rather than repeat it here I will point you to them in the references: the complete three-phase method in Context is the Code, the shift from typing to orchestration in From Writing Code to Directing Intelligence, and the memory question in The Agent Memory Problem.
The scarce resource has shifted. It is no longer implementation skill. It is architectural judgement, problem decomposition, and the discipline to keep context clean. I have spent thirty years building technology. I have never seen a transition this fast or this fundamental.
5. The Receipts, One Build at a Time
If looking back has taught me anything, it is how much I used to leave un-built. The fear of missing out was constant, because so many ideas died on the constraint of a development team I either could not afford or could not wait for. After two years of heavy work with agents, that fear is mostly gone. Here is what came out the other side.
ARIA — the avatar platform (Project-296)
In March of this year I started building an AI avatar platform. I had never built anything like it before. I leaned entirely on my three phases: one week of pure research to find the right Lego bricks for production, which databases, which background services, which model fit where. Then I built. In about six weeks I coded and released a production MVP that was, frankly, far more than an MVP, carrying nearly every feature that later went to production. The only real difference between my MVP and the final system was scale. The codebase ran to over seventeen thousand lines and close to four hundred commits. I used more than three hundred distinct coding-agent sessions, orchestrated through Augment Code’s Intent, and on heavy days I was burning roughly three hundred dollars of credits. Here is the number that still stops me: the client calculated that his own team of five traditional, non-AI developers would have needed at least six months to reach an early MVP, and up to twelve months to reach the state I delivered in six weeks. The productivity gap is not an improvement. It is a change of kind.
Lumina — a SaaS born on a rained-out ski trip
In December 2025 I was on a skiing holiday in the Italian Dolomites when a warm front rolled in and ruined the snow. Rain, no skiing, and suddenly a little time on my hands, which for a founder is a dangerous condition. So I built Lumina Widget. You upload your documents and it turns them into an intelligent chatbot you can embed on a website, share by link, or wire into your tools, in about five minutes. A clean React app with subscription packages. End to end, design to live deployment, it took me thirty days, built with the Augment Code plugin inside VS Code and powered by Haiku 4.5, a genuinely low-cost model. It is live today for anyone to use, and it is my standing proof that you do not need a frontier flagship for every job.
The Curator — the open-source project I am proudest of
The Curator is the open-source work I am most proud of this year. It is a local, AI-powered knowledge-creation system. You drop in a PDF, an article, or a note, and it automatically atomises the source into an interlinked wiki of entities, concepts, and summaries. You can then chat with your own knowledge in a multi-turn conversation, explore the whole thing as a visual graph in Obsidian, sync it privately across your machines through a private GitHub repository, or contribute to a collective shared brain with your cohort or research group. It is grounded in a concept proposed by Andrej Karpathy, and I added an MCP server so that I can query my second brain directly from any of my LLMs. Through that MCP, an agent can both read from and write to the knowledge graph during a session, which makes The Curator, in practice, a persistent long-term memory layer for AI agents. I genuinely use it every day. I store articles, product descriptions, documentation, everything. It needs a Gemini or Anthropic API key for ingestion, but it is otherwise local and fully open. More and more people are using it, which makes me happy in a way the commercial projects do not quite reach. If you find it useful, a star on github.com/talirezun/the-curator genuinely helps the next non-developer find it.
Organisation of Tomorrow — the framework underneath it all
Organisation of Tomorrow - https://github.com/talirezun/oot-framework is a complete, file-based framework for building and running the company of the future. Its central idea is simple and, I think, important: the people who produce value are paid as value compounds, holding real stakes in what they help create, in the same way that the LLMs are paid against the work they do. The technical machinery, the AI agents, the skills, the MCPs, and a collecting brain, compounds the firm’s intellectual property over time. Generation 1 is already in production with two tiers, a privacy tier and a cloud-based tier, and it is designed to be compliant with European regulation. I think of it as a set of Lego bricks any company can pick up and use, and as the connective tissue that turns all the code above into actual business strategy.
And the rest of the last six months
The last six months were the most creative stretch of my building life. A few more that shipped, all powered by Claude, GPT, and Gemini models:
• MountVacation MCP — one of the first open-source MCP servers for the tourism industry. Augment Code plus Claude Haiku 4.5, built during the Anthropic and Gradio hackathon. github.com/talirezun/MV-MCP-server.
• Moj AI — a multi-agent RAG platform that helps users navigate Slovenia’s notoriously complex building legislation. Two orchestrated agents, a year in the making, built with Claude Sonnet and Gemini Pro. mojai.xyz.
• Conduit — an open framework for non-technical people to stand up their own personal executive agent that lives in a folder on their machine, stays inside the boundaries they set, remembers what it learns, and keeps an honest record of what it did. You set it up by pasting prompts. No coding. This one I am genuinely passionate about, because it is about bringing agents closer to ordinary people. github.com/talirezun/conduit-agent.
Four things I learned across all of it, stated plainly:
• Haiku 4.5 is criminally underrated for production SaaS.
• Opus is where serious orchestration lives.
• GPT is extremmly good for deep stack code audits
• Claude Code is a genuinely different kind of creative tool, not just a faster way to type.
• The bottleneck is no longer code. It is context and vision.
6. Solo-with-Agents vs. the Old Way
This is, in the end, an article about productivity, so let me make the comparison explicit rather than leave it implied across the stories above. For thirty years I built the way everyone built: I hired developers, I partnered with technical teams, I raised or spent budgets, and above all I waited. The avatar platform is the cleanest controlled experiment I have, because the client did the counterfactual maths for me. 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, and then some.
I want to be careful here, because hype is cheap and I have spent two years earning the right to be specific. The agents do not replace judgement. They amplify it. Everything I built this year, I built because I already knew how to decompose a problem, when to checkpoint, when to swap a model, when a session’s context had rotted and needed to die, and how to write foundational documents an agent could actually act on. A non-developer can absolutely learn all of that, and faster than they fear, but it is learning, not magic. What has collapsed is the cost of trying. And when the cost of trying collapses, the number of ideas a single person can test in a year explodes. That is the real headline of my contribution graph. Not 1,278. The explosion of attempts that the number represents.
Five developers and a year, or one founder and six weeks. I am not telling you the agents are better than engineers. I am telling you the cost of testing an idea has fallen far enough to change who gets to be a builder at all.
7. If You Are a Founder Reading This: Where to Start
Because this is where life story is supposed to meet practical guide, here is the honest, compressed version of what I would tell any founder who wants to start building this way. The full method lives in the articles referenced at the back; this is the on-ramp.
• Learn the Lego bricks before the agents. Spend a week understanding what a database, an API, authentication, and deployment actually are. You are not learning to code. You are learning enough to direct.
• Treat context as the entire game. Before any code is written, produce your foundational documents: architecture, blueprint, UI and UX, security. Every hour spent here saves five later.
• Pick one agent and go deep. Claude Code, Augment Code, Codex, OpenCode, it matters less than the discipline you bring. Master one before you collect five.
• Watch the context window like a fuel gauge. Around eighty percent, output degrades. Write a handoff file and start a clean session before the model starts contradicting itself.
• Match the model to the job. Haiku for cheap, repetitive production work. Opus for orchestration and judgement. GPT for audits and debuging. You do not need the flagship for everything, and your credit bill will thank you.
• Build in public, including the mess. The wrong-project deploys and the embarrassing bugs are not failures to hide. They are the curriculum.
Beyond my own products, much of my time now goes into teaching exactly this, both inside the COTRUGLI Chasing Jarvis programme and through the writing. I have a lot of opinions and I try to publish them honestly, because a great deal of what circulates online is people repeating each other without having built anything. I would rather offer understanding earned from real builds. If that is useful to you, the work is all linked below, and I am most active on X, LinkedIn, and Substack, where I publish at least once a day.
Start with context. Build with discipline. Deploy with confidence.
The graph is just what that looks like over a year.
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.
Tali’s Links: talirezun.com · x.com/talirezun · linkedin.com/in/talirezun · researchgate.net/profile/Tali-Rezun · github.com/talirezun · talirezun.substack.com
Sources & Further Reading
This article refers throughout to my own earlier field notes, where the methods summarised here are documented in full. They are the primary references for the practical claims above.
1. Režun, T. (2026). Context is the Code: The Complete Three-Phase Process for Building with AI Agents. From Lab to Life. talirezun.substack.com/p/context-is-the-code-the-complete
2. Režun, T. (2026). From Writing Code to Directing Intelligence: Five Days Inside Augment Code’s Intent. From Lab to Life. talirezun.substack.com/p/from-writing-code-to-directing-intelligence
3. Režun, T. (2026). The Agent Memory Problem, and Why It Matters. From Lab to Life. talirezun.substack.com/p/the-agent-memory-problem-and-why
4. Režun, T. (2026). Three Philosophies, One Goal: A Practitioner’s View. From Lab to Life. talirezun.substack.com/p/three-philosophies-one-goal-a-practitioners
5. Režun, T. (2026). Behind the Curtain: The Three-Phase Process I Use to Build Every AI-Coded Product. Medium. medium.com/@talirezun
6. The Curator (open-source). github.com/talirezun/the-curator
7. Conduit Agent (open-source). github.com/talirezun/conduit-agent
8. MountVacation MCP Server (open-source). github.com/talirezun/MV-MCP-server
9. 4thTech: On-Chain Communication Protocol Documentation. wiki.4thtech.io
10. PollinationX: Decentralised Storage Documentation. wiki.pollinationx.io
11. Karpathy, A. (2025). Notes on context engineering and the LLM-as-wiki concept. karpathy.github.io
12. Anthropic (2024). Model Context Protocol. modelcontextprotocol.io
Disclaimer
Research and Educational Purpose. This article is published for research and educational purposes only. The content represents personal experiences, observations, and analysis based on extensive hands-on experimentation with AI agent technologies over the past two years, as well as feedback gathered from MBA workshop participants at COTRUGLI Business School.
No Commercial Relationships. The author has not been compensated, sponsored, or otherwise financially supported by any of the companies, platforms, or tools mentioned in this article, including Augment Code, Anthropic, OpenAI, Google, or any other technology provider referenced herein. All opinions and assessments are based solely on independent research and practical experience.
Figures and Self-Reported Metrics. Commit counts, credit consumption, timelines, and line counts are drawn from the author’s own project records and recollection at the time of writing. Live repository figures change over time and should be verified directly at the source before being cited elsewhere.
Evolving Landscape. The AI agent ecosystem is developing rapidly. Tools, platforms, protocols, and best practices referenced in this article may be superseded, deprecated, or fundamentally changed by the time you read this. Always verify current capabilities and recommendations with primary sources and official documentation.