Why I went from VP Engineering to hands-on builder

TL;DR

What	Details
Background	12 years leadership: Intern → Lead Dev → CTO → VP Engineering -> CTPO -> Founding Engineer. Managed 30 people, recruited 60+ engineers across 6 countries.
Decision	Chose to go back to hands-on building as Founding Engineer (since July 2025).
Why	AI changed where leverage lives. 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 and never look 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.

Not because leadership failed. Because I wanted it, and because AI changed where leverage lives.

---

The trajectory everyone follows

The path is clear: Dev -> Senior Dev → Lead Dev → Engineering Manager -> VP Engineering -> CTO / CTPO

I followed it 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 optimization; caching, async jobs, algorithm rework; we got it down to 4 minutes. 100x improvement. 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. Built a serverless data pipeline from scratch. Led a social plan during Covid; not fun, but I learned resilience under pressure. The hardest lesson? Delegation isn’t abdication. 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 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 Ken and Emry (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. Built teams. Scaled processes. Managed budgets. Recruited talent. Mentored seniors. Led migrations. Organized meetups. Reviewed books (technical proofreader for 3: 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 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 (Claude Code, MCP, Cowork AI workflows), 257 quiz questions with interactive learning paths, 26 AI workflow templates for non-technical users, Rust CLI tools (RTK: 60-90% token reduction, 487K tokens saved), dual-mode dashboard (Ratatui TUI + Leptos Web, 89x speedup with SQLite cache), MCP learning platform (T3 stack).

All solo. No human team. No sprint planning. No 1-on-1s. Just me and a team of AI agents. I’m still an engineering manager, 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 wins on speed. That was impossible before 2025.

---

The honest inventory

What still matters from leadership

Twelve years of management don’t disappear. These skills transfer, but differently.

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

System thinking. Understanding dependencies, blast radius, technical debt; that doesn’t fade. 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.” That’s the leadership speaking. The ability to zoom out while zooming in.

Execution velocity. “Done” beats “perfect” every time. I learned this in management, not in engineering school. Engineering school teaches you to optimize. Startups teach you to deliver. Big difference.

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. Every README is a pitch. Every issue is a spec. Every commit message is documentation. 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 can be wrong. But I’ve learned to trust my gut, my instinct. Some interns I hired became lead developers. Junior engineers turned into seasoned seniors. That pattern recognition doesn’t vanish. When I review code on open-source projects, I can 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. That time is now redirected to building. The ROI shift is massive.

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. Almost zero meetings. All build time reclaimed. As VP at Cheerz, I had 15-20 hours of meetings per week. Meetings drain me; they’re too long, too slow. Now as solo/duo builder? Maybe 2-3 hours max for quick alignment or user interviews. The compounding effect on deep work is real.

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, replays available here) became open-source community building. Same energy, same transparency, different medium. Turns out, building in public is just async meetup organization at scale.

The skills didn’t disappear. They redirected. Building teams taught me how to build products. Managing people taught me how to manage complexity. The model changed, not the underlying capabilities.

What I’m building now

Current active projects (all solo, all AI-assisted):

Claude Code Ultimate Guide ; Complete learning system built in 2 months. 257 quiz questions across 6 learning paths, 16,000 lines of documentation. Interactive quiz with instant feedback. Technologies: GitHub Pages, MiniSearch, MDX, TypeScript.

RTK (Rust Token Killer) ; Rust CLI proxy that condenses command outputs for LLM consumption. 60-90% token reduction measured across git, gh, pnpm, vitest, playwright. Real impact: typical Claude Code session went from 101K tokens to 22K tokens (79% reduction). 487K tokens saved to date.

ccboard ; Dual-mode dashboard for real-time Claude Code monitoring. Ratatui terminal UI + Leptos web interface sharing the same Rust backend. SQLite caching delivers 89x speedup on repeated queries.

CC Copilot Bridge ; Multi-provider routing with 3-char aliases. Bash-based router for switching between Anthropic, GitHub Copilot, and Ollama instantly. Built because context-switching between LLM providers was killing my flow.

Claude Cowork Guide ; 26 workflows for non-developers: marketing, sales, support, operations. Templates ready to use. Built because most AI guides target developers. Non-tech teams need workflows too.

MCP Guide Assistant ; In development. Interactive assistant for building MCP servers with code generation from official documentation. Bridges the gap between reading docs and actually building.

One person. Seven products in parallel, and counting. All in active development. That was impossible 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. Pull requests multiply. Experiments compound. The bottleneck isn’t the tools anymore; it’s my brain’s capacity to track everything in parallel. With AI, velocity can scale exponentially, both in the right direction (rapid feature delivery, fast iteration) and the wrong one (bugs multiply just as fast, technical debt accumulates at speed, breaking changes cascade). The number of PRs is staggering. The pace is relentless. Everything needs constant reevaluation because what worked yesterday might be obsolete tomorrow. This isn’t sustainable at infinite scale, but it’s exhilarating at current scale. The limit isn’t the code; it’s the cognitive overhead of orchestrating seven moving targets simultaneously.

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 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.

What this means for everyone

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 leverage AI tools well, 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. The truth isn’t binary; it’s contextual.

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 isn’t a leap; it’s pattern recognition.

For Engineering Managers: The role isn’t disappearing, but it’s evolving. 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-leverage 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 feeling. The shift from leader to builder isn’t regression. It’s redirection.

“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

Code every week. No exceptions. If you stop coding for 6 months, you’re not a “technical VP.” You’re a people manager with outdated technical opinions. At Cheerz, I was 80% management / 20% hands-on. That 20% kept me credible. Without it, I would have been flying blind on technical decisions. I would have approved architectures I didn’t understand. Made bets I couldn’t evaluate. Lost the team’s technical respect.

AI fluency is now a core leadership competency. A VP who doesn’t use AI coding tools daily (Claude Code, Copilot, Cursor, Gemini Code Assist, or equivalents) can’t evaluate how teams should use them. You’re managing a workflow you don’t understand. That’s dangerous. It’s like managing a sales team without knowing Salesforce, or a marketing team without understanding analytics. The tool IS the workflow now.

Throughput > Title. Delivering 7 active open-source projects (for now!) is more credible than “VP Engineering at Stealth Startup” on your LinkedIn. Build your reputation through what you deliver in public, not through titles. Titles impress recruiters. Shipped products impress builders. Choose your audience.

The best builders are playing a different game. Top engineers aren’t climbing the management ladder anymore. They’re building products solo and scaling through AI. If you want to attract them, you need to understand their game. Lead by example. Code with them. Build with them. Don’t just “set direction” from a conference room.

Management is a specialization, not a promotion. Stop treating “IC → Manager” as career progression. It’s a fork. Different skills. Different models. Both valid. Neither superior. Choose deliberately. I chose building. I don’t regret the 12 years in leadership; they taught me how to deliver, how to prioritize, how to build culture. But I’m not going back full-time. The model shifted.

Current status

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.

The interesting part: our Build vs Buy evolution. Started Buy-heavy (faster to market), evolved toward selective Build as we understood the core differentiation. Not dogmatic; pragmatic. Buy for commodities, build for 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.

Solo builder (side projects). 7 active open-source projects. Full-time exploring the new frontier in parallel.

The beauty: I can do both. Founding Engineer by day. Solo builder by night. AI made this possible.

Who I am

• Passionate geek since forever. Started coding young, never stopped.

• Leadership based on transparency and energy. No bullshit, no politics.

• Core values: loyalty, ambition, benevolence.

• “Go to bed smarter than when you woke up” (Charlie Munger). Or “go to bed less stupid than the day before”; same mindset, different words.

• Rational + pragmatic, but trust intuition when data is incomplete.

• Always learning: Clean Architecture, Radical Candor, The Phoenix Project, Team Topologies.

• Tech Ambassador at scale: organized 10+ meetups at Cheerz (replays available here, 30→120 attendees).

• Fluent FR & EN. Managed non-French speaking teams (Bulgaria, England, Vietnam, Poland, Tunisia).

• 60+ recruitments (80% direct, no headhunters). I know how to spot talent.

• Domains: SaaS, E-commerce, Data, B2B & B2C, AI, EdTech

• Company stages: early stage → post seed → post A-series → scale-up → post buyout

• Team topologies: hybrid & full remote, multi-country

---

GitHub: @FlorianBruniaux

LinkedIn: Florian Bruniaux

Méthode Aristote

---

Built with Claude Code. Delivered in public. Living the shift.