From VP engineering to solo builder: my honest take
What roughly 15 years in software, including 8 to 10 in leadership, give me as an AI-assisted builder, what I had to relearn, and why faster code is not enough.
Jump to summary ↓TL;DR
I think the ratio of builders to managers that made sense in 2020 no longer holds in 2026, and that it is about to invert. In my experience, one AI-assisted senior now produces what 3 to 5 people did before; that is a felt comparison, not a measurement. The management layer that exists purely to coordinate is the one under pressure, while people development, technical vision, culture and architectural bets keep their value.
Going back to building also meant learning a different way to work. My experience helps me decide what to build and judge the result, while I learn how to delegate more of the execution. The time and resources available for that learning matter, and faster delivery still leaves me responsible for whether anyone uses what we ship.
| What | Details |
|---|---|
| Background | Roughly 15 years in software, including 8 to 10 in lead and leadership roles, Lead Dev included: Intern → Lead Dev → CTO → VP Engineering -> CTPO -> AI Founding Engineer. Managed 30 people, recruited 60+ engineers across 6 countries. |
| Decision | Chose to go back to hands-on building as AI Founding Engineer (since July 2025). |
| Why | AI shifted where the work creates impact. Solo builder with AI now matches small team output from 3 years ago. |
| Still valuable | Systems thinking, execution velocity, scope discipline, communication, hiring instinct. |
| Obsolete (for solo) | 1-on-1s, sprint planning, stakeholder alignment, meeting culture, middle management coordination. |
| Projects and contributions discussed | 7+ open-source projects, 16K lines of docs, 473 quiz questions (as of October 2026), Rust CLI tools. My personal projects are built solo with AI. RTK is collective, and I am a historical contributor and current supporter. |
| The shift | Management-to-builder ratio inverting. In my experience (felt, not measured), 1 AI-assisted senior = 3-5 people before. Managers now need exceptional people development, not just coordination. |
Most engineering leaders climb the ladder without looking back.
Dev -> Senior Dev → Lead Dev → Engineering Manager -> VP Engineering -> CTO / CTPOI have roughly 15 years of experience in software, including 8 to 10 in lead and leadership roles, Lead Dev included. Built multiple teams from scratch. Managed up to 30 people. Recruited 60+ engineers across 6+ countries.
Then I chose to go back to code as a senior IC. Leadership had not failed. I wanted it, and AI shifted where the work creates impact.
The trajectory everyone follows
That path covers roughly 15 years in software, including 8 to 10 in lead and leadership roles.
The formative years (2013-2018) laid the foundation. At EDF (2013-2014), internship turned into first real deployment: MVP in a nuclear power plant. You learn rigor fast when mistakes have consequences. At Aussiito (2014-2017), I built my first team from 0 to 10 people. Migrating 1M+ lines of legacy PHP to Symfony + Angular while keeping the business running taught me more about people management than any book. The hardest part wasn’t the code; it was recruiting without headhunters. I learned to spot talent in interviews, not on CVs. 80% of my best hires came from unconventional profiles.
At Qemotion (2017-2018), same pattern: team 0 to 6, Rails monolith refactor, NLP pipelines in Python. One data processing job took 6 hours for 10k documents. After optimizing the caching layer, rethinking the async jobs, and rewriting the core algorithm, we got it down to 4 minutes. 100x. The CEO asked if I’d cheated. No magic, just methodical profiling and smart architecture choices.
The scaling phase (2018-2023) taught me coordination at scale. At Explain (2018-2021), I scaled from a core team of 6 to 2 multidisciplinary teams totaling 14 people. I built a serverless data pipeline from scratch. Leading a social plan during Covid was not fun. It taught me resilience under pressure. The hardest lesson was delegation. I made both mistakes: micromanaging everything (burnout), then delegating without follow-up (tech debt). Finding the balance took 18 months.
At Cheerz (2021-2023), VP Engineering managing 30 people (15 direct reports, rest via leads). I recruited 15+ engineers during the tightest hiring market ever. Organized 10+ tech meetups that grew from 30 to 120 attendees (replays available here). Led FinOps optimization that cut 10% from a 350k€ budget. I learned that culture scales through transparency and energy, not process documents.
The hybrid return (2023-2025) bridged the old and new worlds. At Native Spaces, CTPO role but 70% hands-on (fullstack TypeScript/Next.js/React Native). Hired few engineers + 1 designer + 1 SEO. Inherited a legacy PHP monolith (PHP 4, mess of spaghetti code). Refactored it, migrated to PHP 8, improved architecture. But we hit the wall: technical debt too deep, wouldn’t scale. Decision: rebuild v2 from scratch. Led the complete platform rewrite while keeping v1 running. That 70% coding time kept me credible on technical decisions. Without it, I would have been managing a workflow I didn’t understand.
In July 2025, I joined as AI Founding Engineer & CTO at Méthode Aristote (EdTech + AI, Cartesia Education group). T3 stack (Next.js, tRPC, Prisma, PostgreSQL). Full ownership: architecture, product, technical strategy. The deal was bold. When Ben and Aimery (cofounders, my bosses) asked me if I could ship the platform from scratch, the timeline was tight: July 15th start, September 1st deadline. Six weeks, full platform, solo. I said “deal, but I’m going all-in on AI.” No time for perfect architecture. No time for overthinking. Ship fast, iterate later. Claude Code, Cursor, aggressive scaffolding, pragmatic shortcuts where it made sense. The kind of pace that would have required a team of 3-4 engineers and 3-4 months before AI. We shipped on time. Started solo on tech, recruited a founding product designer after 6 months. Built an AI-augmented dev environment (Claude Code, Cursor) with advanced configs to enable non-technical team members to build and ship to production alongside me. Took a few weeks to set up, but now it works. The product designer ships features directly.
Everything leadership books tell you to do? I did it. I built teams and scaled processes, managed budgets, recruited talent across 6 countries, mentored seniors through technical transitions, led platform migrations while keeping the business running, organized meetups, even did technical proofreading for 3 books (Backbone.js, JS Regex, Mastering Grunt).
And it worked.
What changed: AI rewrote the equation
Traditional model in software: You can’t scale yourself, so you scale through people. A lead developer manages 5-8 engineers. A CTO coordinates 2-3 leads. A VP Engineering oversees 15-30 people. That math held for 30 years.
AI broke it.
With Claude Code, a single senior builder (who knows what they’re doing and where they’re going) can now produce output comparable to a small team from 3 years ago. While working full-time as AI Founding Engineer at Méthode Aristote, I was also building: 7 open-source projects in active development, 16,000 lines of documentation across 3 guides, 473 quiz questions (as of October 2026) with interactive learning paths, Rust CLI tools (RTK, a collective project I contributed to: 60-90% token reduction, 487K tokens saved), dual-mode dashboard (89x speedup with SQLite cache). On RTK, I am now a historical contributor and supporter. These remain the metrics in this account, not results I can claim as their sole author.
My personal projects were built solo with AI agents running in parallel, without sprint planning or 1-on-1s. My contributions to RTK were part of a collective project. I’m still an engineering manager in some sense, but now I manage AI agents instead of people.
The throughput gap between “VP with team” and “senior builder with AI” has collapsed. In some domains, the solo senior builder now wins on speed. Before 2025, I could not have done this.
The honest inventory
What still matters from leadership
Those years in lead and leadership roles left skills that transfer differently.
Scope discipline. Sometimes I ask the agent to remove a feature it has just added. It might be nice, but we had not planned it, written the specs or tested it. I ask for it to go back into the backlog or onto a separate branch. The fact that it is already coded does not give me a reason to ship it. I talked about this during the Insitoo live: delegating implementation still leaves me with the decision about what goes into the product.
Systems thinking. Understanding dependencies, blast radius, technical debt: none of that fades. When I code on these projects, I still think like an architect. Not “how do I make this code work” but “how does this feature impact the entire system in 6 months.” The ability to zoom out while zooming in.
Execution velocity. Management taught me that “done” beats “perfect”. Engineering school taught me to optimize, while startups taught me to deliver. I did not understand the distinction until I had been through both.
Communication. Writing clear docs, READMEs, GitHub issues: still core. Building alone doesn’t mean building in silence. If anything, async written communication matters more when there’s no team to verbally align with. A README is a pitch. An issue is a spec you’ll reference 3 months later. A commit message is the one piece of context that survives a rewrite. At Cheerz, I evangelized documentation culture: API contracts, contract-first approach, clear specs. It worked, but it was slow. Writing took time. Now with AI, it’s automated. Give it the right style guide, and it produces excellent documentation instantly. Same standards, 10x faster.
Hiring instinct. I recruited 60+ people (80% direct, no headhunters) across Bulgaria, England, Vietnam, Poland, Tunisia, France. I know what good looks like. It’s not an exact science. I’ve been wrong before. But I’ve learned to trust the pattern recognition that builds up over 60+ hires. Some interns became lead developers. Junior engineers turned into seasoned seniors. When I review code on open-source projects now, I can still spot who has potential vs who’s just following tutorials. Same instinct, different application.
What became obsolete (for solo building)
Process optimization. No sprint planning, no stand-ups, no retros when there’s no team. I don’t miss optimizing Jira workflows. I miss solving technical problems. Turns out, I always preferred the latter.
Stakeholder alignment. When you’re the founding engineer, technical decisions happen fast. At Cheerz, a major architecture change took weeks of alignment. At Native Spaces, a few days. At the start of building Méthode Aristote, alone on the technical side? A few hours to prototype and validate directly with users.
Meeting culture. As VP at Cheerz, I had 15-20 hours of meetings per week. Now maybe 2-3 hours for quick alignment or user interviews. Meetings drain me. They run too long and move too slowly. The reclaimed time goes directly into the codebase.
Middle management coordination. No need to coordinate between teams when you are the team. No translation layer between “what the business wants” and “what engineering can deliver.” I am both layers. Faster feedback loops, less information loss.
What transferred surprisingly well
Leadership skills didn’t disappear. They redirected. Roadmap thinking became multi-project pipeline management. I still plan quarters ahead, but for feature releases instead of team capacity. Risk assessment became experiment prioritization: which bets to take, which to defer. Budget management shifted from team salaries to personal infrastructure costs (AWS, Vercel, hosting). Same FinOps discipline, smaller scale.
The most unexpected transfer? Delegation skills became agent orchestration. I used to delegate tasks to senior engineers with clear context and autonomy. Now I delegate to AI agents (Claude Code, GitHub Copilot, MCP servers) with the same approach: clear context, defined scope, validation checkpoints. The mental model is identical. The execution layer changed. The later article on responsibilities around context engineering separates specification, harness, identity and evaluation work that someone still needs to own.
The environment adapted too. As VP, a laptop and a meeting room were enough. As builder, I needed a multi-screen cockpit: terminals, code editors, AI agents, documentation, all visible at the same time. Same multitasking instinct from managing multiple teams across different stacks, now applied to multiple projects on multiple screens.

Tech ambassador work (organizing 10+ meetups at Cheerz, growing attendance from 30 to 120) became open-source community building. The energy transfer was the same: different medium, same underlying dynamic.
My 8 to 10 years in lead and leadership roles gave me system-level thinking that I now apply to product architecture. Managing people taught me to see complexity at scale, which transfers directly to orchestrating parallel projects. The medium changed while the underlying judgment remained.
What I’m building now
Open-source projects and contributions since early 2026, with AI assistance. This list combines personal creations and collective contributions at different maintenance stages:
Claude Code Ultimate Guide • RTK (Rust Token Killer) (historical contribution, current support) • ccboard (less actively maintained today) • CC Copilot Bridge • Claude Cowork Guide • MCP Guide Assistant • Dual TUI/Web Dashboard
One person now manages seven simultaneous contexts. I could not do that 2 years ago.
The velocity keeps increasing. That’s the part that surprises me most. I’m not plateauing, I’m accelerating. Features ship faster, PRs accumulate, experiments run in parallel. The constraint is my brain’s capacity to track everything simultaneously, not the tools. With AI, velocity scales exponentially in both directions: rapid feature delivery and fast iteration, but also bugs multiplying just as fast, technical debt accumulating at speed, breaking changes cascading. The pace is relentless, and everything needs constant reevaluation because what worked yesterday might be obsolete tomorrow. The pace is exhilarating at current scale, with a ceiling I haven’t hit yet. The limit is the cognitive overhead of orchestrating seven moving targets at once.
I have also run into a less flattering consequence: losing track and throwing away the work produced. During the Insitoo live, I talk about thirty or forty sessions, but I do not manage them all at the same time. I move from a plan to a check and keep track on my reMarkable. That has not stopped me from wasting time and tokens. That discarded work is part of the cost of how I work. The number of sessions does not tell you how much useful work comes out of them.
The uncomfortable truth about engineering leadership in 2026
The manager-to-builder ratio is about to invert.
The old math (2020)
When I was building teams at Aussiito, Qemotion, Explain: 1 lead developer for 5-8 engineers, 1 CTO for 2-3 leads, 1 VP Engineering for 15-30 people. This was efficient. This was necessary.
The new reality (2026)
In my experience, one AI-assisted senior engineer produces what a team of 3-5 people did before. That is a felt comparison, not a measured one, and I see it every day. At Native Spaces (2023-2025), 70% hands-on as CTPO, I rebuilt the entire platform (backend, frontend, mobile) with a small team while the business grew 4x. At Méthode Aristote, starting in July 2025, I began alone on the technical side to build the EdTech platform, then opened contributions to other profiles. In open source, I have built personal projects and contributed to collective ones that would have required dedicated teams before. For RTK, I remain a historical contributor and current supporter.
This shift is real.
How the role changes by seniority
Context: These observations come from my specific trajectory. Different industry, company size, team maturity will create different realities.
A junior can surprise you on a bounded task. A junior contributing to a repository built by a senior (clean architecture, clear patterns, solid foundations) can move faster than a senior who refuses AI. If the junior understands the existing system and uses the tools effectively, the speed can surprise me. That says little on its own about their ability to diagnose a failure, challenge a requirement, or assess consequences elsewhere in the product. For rapid prototyping or well-scoped features on established codebases, I would consider that contribution seriously. For complex architectural decisions, production-critical systems, or greenfield projects requiring deep judgment, I still need the experience behind those decisions. A working feature is one piece of evidence when I hire someone.
Experience gives me a starting point. I’ve seen seniors who went hands-off years ago come back into the technical work faster than expected. Their foundations helped them evaluate what the tools produced: design patterns, system thinking, software engineering principles. In my own work, I spend less effort remembering every API and more on deciding whether an approach fits. That experience helps me learn a new practice without starting my career over. It still takes practice, including learning where the tools fail and when I need someone else’s judgment.
Who adapts fastest to AI? In my observation: Staff Engineers, Engineering Managers, and Senior Software Engineers who’ve operated across multiple projects in parallel. These profiles already developed the mental model of context-switching, prioritizing, orchestrating. They managed complexity at scale: whether through people or through systems. AI feels natural to them because it’s another layer to orchestrate. If you’ve juggled 3 teams, 5 repos, and 10 stakeholders simultaneously, orchestrating AI agents across 7 projects is the same cognitive skill applied to a different medium.
For Engineering Managers: The role is changing shape. Pure coordination (translating requirements, unblocking people) is getting compressed by AI and async tools. What remains valuable: exceptional people development, strategic technical vision, building culture, making high-stakes architectural bets. If your value is “I keep things running smoothly,” that’s a weaker position than before. If your value is “I grow engineers into leaders, I shape how we build, I see around corners on technical strategy,” you’re in a strong position. The distinction matters.
For VPs/CTOs: You’re now competing with AI-assisted senior builders on execution speed. Your differentiation is long-term architecture vision, team culture at scale, hiring and talent development, strategic technical bets that span years. If you stopped coding 5+ years ago and your main job is meeting facilitation, consider whether that’s still the highest-impact position. Some contexts still need pure coordinators. Many don’t anymore.
Each person decides where they fit. I chose building. Not because it’s “better” than management. Because I wanted it. I needed it. I’m a geek at heart, always have been. Right now I’m in this phase of mental excitement where everything can move incredibly fast, and that energy is addictive. For years, I genuinely thought I was the hands-off engineering manager type, built for scaling teams and optimizing processes. Turns out I was wrong. I identify more with the early-stage builder, the indie hacker mindset: shipping fast, iterating constantly, launching projects at a pace that feels alive. And the reason I can pull this off? Roughly 15 years in software, including 8 to 10 in lead and leadership roles. Every team I built, every process I scaled, every architecture I reviewed gave me the judgment to move fast without breaking everything. The trajectory wasn’t a detour. It was the foundation.
I’m not the only one close to me who made this shift. My wife Pauline was CPO at a tech company. After a layoff, she didn’t chase the next CPO role. She rebuilt from scratch: launched Bel Etage, an interior architecture studio. Manager to maker, different industry, same pattern. Watching her navigate the doubt, the energy shift from delegating to doing, confirmed what I was already feeling. Going back to building felt right in a way I hadn’t expected.
“Management is dead”? No. That’s naive. Complex products still need coordination across teams, engineering culture at scale, hiring and talent development, strategic technical direction. But the ratio changes. Before: 1 manager for 7 engineers was healthy. Now: 1 manager for 15 AI-assisted engineers might be viable in some contexts. The middle management layer that exists purely to coordinate and translate is under pressure. Not eliminated, but compressed. If you’re in that layer, the question isn’t “Am I at risk?” but “What unique value do I bring beyond coordination?” Answer that clearly, and you’re fine. Avoid the question, and the environment will answer it for you.
Being experienced and learning again
Preparing an Insitoo discussion on AI and software work brought this back to a career question. If I delegate more of the implementation, what am I being paid for? My answer starts with the decisions around that work: understanding the problem, setting expectations, and deciding whether the result is good enough. Learning to work this way adds something to my experience, though it can also mean giving up familiar ways of showing that I know what I’m doing.
I have never been particularly attached to typing the code myself. I enjoy solving problems, which made delegating the implementation an appealing change for me. I can understand why it feels different for someone who spent years taking pride in how well they could write that code. Telling them to lose the ego skips over the work they invested in becoming good at it. They may need to discover where that knowledge helps in a practice that initially feels unfamiliar.
What my experience still lets me do
The delegation mistakes I made at Explain remain useful to me. I had tried controlling everything, then handing work over without enough follow-up. Those experiences help me ask what someone needs before they can work independently and what I need to check afterward. I use those questions when delegating to an agent, while learning which parts of the comparison with a human colleague hold up.
The same applies to product decisions. I can ask why a feature belongs in the product, whose problem it solves, and what evidence would make us change direction. An agent can help me investigate those questions. I still have to make a choice with the information available and explain that choice to the people affected by it.
For a senior developer, that leaves room to be experienced in engineering and a beginner at a new way of working at the same time. I would want to see them apply their judgment to a bounded piece of work, explain what they delegated, and recognize where the result needs closer inspection. Learning a tool becomes more useful when they can connect it to a decision they already know how to evaluate.
Learning needs room in the job
Damien Cavaillès raised a practical objection during that conversation: people can be willing to learn while their employer limits the tools and budget available to them. He also described failed attempts before he had a setup he trusted. That belongs in any account of how someone changes their practice.
My own setup includes paid tools, equipment, and a research budget. I choose to spend personal time experimenting because I enjoy it and it has become part of my specialization. That gives me opportunities to try things that someone restricted to an approved tool at work may not have. I need to account for those conditions before drawing conclusions about their willingness or ability to learn.
If I am asking an employee to change how they work, I need to make room for learning inside the job. That means access to suitable tools, time to try a bounded task, and someone available when an attempt fails. I would ask the employee to explain what they tried and what they learned. I would also ask their manager what the organization made possible.
Faster delivery can still miss the point
Damien also challenged the productivity claim: more speed at doing what? I had an uncomfortable example from Méthode Aristote. We had shipped features we were pleased with, then added usage tracking and found they were not being used. I cannot turn that account into a measured return on AI without more data. It did give me a reason to question what I was counting as progress.
I enjoy being able to build something that would previously have needed a team. That makes it tempting to keep building. The ability to produce another feature leaves me with the decision about whether it belongs in the product, and with the work of finding out how people use it.
That is where my leadership experience still earns its place. I can bring scope discipline to the decision, talk to users, and challenge my own enthusiasm for making something. The satisfying part of this career change is having more ways to act on a problem. I still need to check whether the thing I chose to do helped anyone.
What I’d tell my VP-self from 2021
The 20% coding time at Cheerz was the only reason I stayed credible on architecture decisions. When I fell below that, I felt it: approving things I didn’t fully understand, making bets I couldn’t evaluate, relying on the team to catch what I’d missed. That 20% wasn’t arbitrary. It was the minimum viable signal that I still understood what I was asking of people.
AI fluency works the same way. I was briefly behind on this in late 2024, before I went deep on the configuration side. Managing a workflow you don’t understand means you’re a bottleneck that doesn’t know it’s a bottleneck. A VP who hasn’t seriously used Claude Code or Cursor recently can’t evaluate how their team should use them, not as a value judgment, just as a practical limitation: you’re reasoning about a process you haven’t run.
My credibility in open-source conversations now comes from what I’ve shipped, not from “VP Engineering” in a bio. That was a genuine surprise. I spent years collecting titles and discovered that the builders I want to work with look at GitHub, not LinkedIn. Different audiences, and I’d been optimizing for the wrong one for a while.
For most of my career, I treated the IC to Manager track as straightforward growth, moving in that direction partly by inertia. The deliberate choice came late. I don’t regret those years of leadership, they’re the reason I can move fast now without breaking everything. But if I had to do it again, I’d have made the choice earlier.
Current status
I now work as a Fractional Chief AI Officer, on a freelance basis, with startups, large organisations and investment funds. I audit the full chain across processes, product, strategy, technology and budgets to identify problems and prioritise changes. My collaboration with Méthode Aristote has continued on a freelance basis since October 2026.
I joined Méthode Aristote in July 2025 to build its EdTech platform within the Cartesia Education group. The work spans architecture, product and technical strategy, using Next.js, tRPC, Prisma and PostgreSQL.
Our Build vs Buy approach changed with the product. We started Buy-heavy to reach the market faster, then moved toward selective Build as we understood the core differentiation. We buy commodities and build the competitive moats.
AI work includes real complexity: semantic search with Elasticsearch/TypeSense evaluation (precision vs cost trade-offs), database vectorization for similarity matching, embedding pipelines for content recommendations. Not “ChatGPT wrapper” territory. Actual infrastructure decisions with measurable performance impact.
In parallel, 7 open-source projects and contributions discussed here, since early 2026. Their maintenance pace varies. I maintain ccboard less actively today, and my role on RTK is that of a historical contributor who continues to support the project.
Who I am
Geek since forever, roughly 15 years in software including 8 to 10 in lead and leadership roles, now back to building.
I care about getting things right more than looking like I have it figured out. Transparency over politics, documenting failures as clearly as wins, shipping something testable before presenting it as solved. Charlie Munger’s version: “go to bed slightly less stupid than you woke up”. That’s the operating system. Some days it’s a new architectural pattern. Some days it’s a chapter of The Phoenix Project on the train.
French and English fluent. Managed non-French speaking teams across Bulgaria, England, Vietnam, Poland, and Tunisia. 60+ engineers recruited across that career, 80% without headhunters. Domains: SaaS, e-commerce, data, B2B, B2C, AI, EdTech, every company stage from pre-seed to post-buyout.
The builder-to-manager ratio
Those years of building and supporting teams gave me one thing I couldn’t have gotten any other way: the judgment to know what to skip. AI gave me the speed to act on that judgment without waiting for a team to align. Those two things together changed the math on what one person can ship. The uncomfortable part, for anyone in engineering leadership right now, is that this isn’t a temporary edge case. The ratio of builders to managers that made sense in 2020 doesn’t hold in 2026, and pretending otherwise is a choice, not a strategy. I’m not saying everyone should drop management and go back to code. I’m saying the ones who refuse to look at the numbers honestly are going to be surprised by them.
GitHub: @FlorianBruniaux
LinkedIn: Florian Bruniaux
Built with Claude Code and delivered in public.
YSNK
(You should now know)
- The 20% coding-time rule at Cheerz was concrete: falling below it meant approving architecture decisions he could not fully evaluate
- One optimization at Qemotion cut a 10k-document processing job from 6 hours to 4 minutes, 100x, through profiling and caching. No shortcuts, no magic
- A junior’s working feature is useful hiring evidence. It does not establish their ability to diagnose failures, challenge requirements, or make architectural decisions
- Engineering experience can help while learning a new practice; access to tools, time to experiment, and support affect that learning
- At Méthode Aristote, usage tracking revealed that features we were pleased to ship were not being used. That experience changed what I was willing to count as progress
Go Further in the Claude Code Guide
Practical resources selected to help you take the next step.
These resources provide adjacent lenses. They are not maturity stages.
Related appearances
Live appearances and podcast episodes about this article.