From VP engineering to solo builder: my honest take

TL;DR

What	Details
Background	12 years leadership: 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	System thinking, execution velocity, scope discipline, communication, hiring instinct.
Obsolete (for solo)	1-on-1s, sprint planning, stakeholder alignment, meeting culture, middle management coordination.
Current output	7+ open-source projects in parallel, 16K lines of docs, 257 quiz questions, Rust CLI tools. All solo, all AI-assisted.
The shift	Management-to-builder ratio inverting. 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 / CTPO

I climbed it for 12 years. 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

I followed that path for 12 years.

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.

Since July 2025, I’m 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’m building in parallel: 7 open-source projects in active development, 16,000 lines of documentation across 3 guides, 257 quiz questions with interactive learning paths, Rust CLI tools (RTK: 60-90% token reduction, 487K tokens saved), dual-mode dashboard (89x speedup with SQLite cache).

All solo, no sprint planning, no 1-on-1s. Just me and a set of AI agents running in parallel. 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

Twelve years of management left skills that transfer differently.

Scope discipline. I’m delivering 7 projects because I said no to 70 ideas. That’s focus, not productivity. Every cool idea I skip makes me stronger on the ones I keep, and you don’t learn that discipline coding alone. You learn it managing competing priorities with limited resources. Parallelization comes naturally because I spent years managing multiple teams simultaneously, coordinating leads across different stacks. Juggling 7 projects feels familiar, just a different execution layer.

System 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)

People management overhead. 1-on-1s, performance reviews, conflict resolution: zero of this when solo. I spent 70-80% of my VP time on people ops, which meant 70-80% of my time was not spent building. That math hit me about 6 months into the current role.

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. Now at Méthode Aristote, solo? 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 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.

Building teams for 12 years 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

Seven open-source projects in active development, all solo, all AI-assisted:

Claude Code Ultimate Guide • RTK (Rust Token Killer) • ccboard • 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.

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)

One AI-assisted senior engineer produces what a team of 3-5 people did before. 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 (since July 2025), solo AI Founding Engineer building the EdTech platform with full ownership. In open-source, I’m delivering 7 projects that would have required dedicated teams before.

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.

Junior with AI on well-architected code > Senior without AI. Nuance matters here. A junior isn’t inherently better than a senior. But 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 is smart enough to understand the existing system and use AI tools effectively, velocity can surprise you. That said: quality might differ, bugs might slip through, edge cases might be missed. Context matters. Stakes matter. For rapid prototyping or well-scoped features on established codebases, the junior with AI wins on speed. For complex architectural decisions, production-critical systems, or greenfield projects requiring deep judgment, experience still dominates. Context determines the answer, and context varies enormously.

The seniors who thrive: Experience + AI = force multiplier. Not “experience OR AI.” Both. I’ve seen seniors who went hands-off years ago come back into the technical game faster than expected. Why? Their foundations were solid: design patterns, system thinking, software engineering principles. With AI, the implementation gap shrinks. You don’t need to remember every API; you need to know which architecture fits. Seniors with strong fundamentals can ramp back up surprisingly fast. Those who refuse AI on principle lose ground. But those who embrace it become unreplaceable because they combine judgment with speed.

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? Twelve years of leadership. 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, 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.

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 12 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 the 12 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 at year 4 instead of year 12.

Current status

AI Founding Engineer & CTO at Méthode Aristote (full-time, since July 2025). EdTech + AI. Building platform to help students learn better. Cartesia Education group. T3 stack (Next.js, tRPC, Prisma, PostgreSQL). Full ownership: architecture, product, technical strategy.

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 active open-source projects. I wasn’t sure this double pace would hold. It has, so far.

Who I am

Geek since forever, manager by choice for 12 years, 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 over 12 years, 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

Twelve years of building and managing 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

Méthode Aristote

---

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
• Junior-with-AI on a well-architected codebase can outpace senior-without-AI on rapid prototyping and well-scoped features. For production-critical systems and greenfield architecture, experience still dominates. Context decides which
• Delegation skills transferred to agent orchestration almost unchanged: clear context, defined scope, validation checkpoints, same mental model, different execution layer
• Credibility in open-source conversations now comes from what’s shipped on GitHub, not a “VP Engineering” line on LinkedIn, a genuine surprise after 12 years collecting titles