Decebal | Rust + Move Engineer ⚙️

🦀 Rust & Move Development Services - High-performance backend APIs (Actix/Axum) - Smart contracts on Sui & Aptos - Cloud integration (AWS / GCP) - Fractional CTO guidance for scaling startups 🔗 Let’s build something fast, safe, and future-proof. 💬 DM me or visit decebaldobrica.com

The right framing isn't Rust vs C++ safety tooling. It's about what fits the codebase you already have. For greenfield projects, Rust's ownership model catches entire categories of bugs at compile time. For existing C++ codebases with millions of lines, tooling like this is genuinely more practical. Both paths lead to safer software. The engineering question is which one costs less for your specific situation.

This is interesting — a compiler/runtime that makes almost all standard C/C++ code completely memory safe. The performance overhead is not negligible, but there are plenty of cases where “rewrite it in rust” still isn’t a practical solution.

Yes, and here's why. AI generates code, but it doesn't understand the system it's building for. Someone still has to design the architecture, handle the failure modes, and make sure everything holds together under real traffic. The engineers who will thrive are the ones who can think above the code level. Understanding constraints, tradeoffs, and why a system should work a certain way is the part AI can't replace.

If AI can generate apps now… is becoming a software engineer still a good career?

The timing argument is underappreciated. AI landing right as interest rates were squeezing growth gave companies a real productivity lever instead of just cutting headcount. From the engineering side, the teams I've seen get the most out of AI tools are the ones that already had strong fundamentals. Good type systems, solid testing, clear architecture. AI amplifies quality, it doesn't create it from scratch.

If it wasn’t for AI there would be a huge recession. It’s just dumb luck that AI happened to work at the end of the last business cycle. Productivity in everything important is going up because of it. Chemistry, biology, finance, software, mechanical engineering, etc… the next decade is going to be nuts in terms of growth.

incredible shift happening believe we are at stone bottom for crypto sentiment, AI has been primary driver of returns for risk across all asset classes & core fundamentals of crypto-graphy are uniquely complementary to AI: private money, private programmability, provenance of human-generated content

LOC as a metric is doing a lot of heavy lifting in this comparison. Raw output was never the bottleneck for a 450-person team. It was coordination, design decisions, debugging, and making sure the code actually works together. The real comparison should be: how much of that token-generated code ships to production without a human rewriting it first? In my experience, the answer changes the math significantly.

I did the math, and $2M in OpenAI tokens is equivalent to a 450 pre-AI human engineering team for 2 years, in terms of raw LOC output.

This is the most predictable cycle in tech. The same panic happened with outsourcing fears in the 2000s. Everyone who stayed got rewarded when supply cratered. What makes this round different is the engineers who learn to work with AI tools now will be even more scarce and valuable. The ones who left? They won't easily come back to a field that moved this fast without them.

> be a software engineer > tell everyone “we’re cooked” > post about ai layoffs that have nothing to do with ai > nobody will study cs > programmers will switch jobs > congrats, in 5 years software will have a demand spike with no supply because “ai was gonna replace us all”

There's a real truth to this. Software engineers are the ones building the automation that touches every other industry. If AI gets good enough to fully replace the people building AI, it's certainly good enough to replace everyone else too. What I've seen in practice is that AI is making engineers more productive, not redundant. The bottleneck has shifted from writing code to understanding systems, making architectural decisions, and knowing what to build in the first place.

If software engineers go out of job , everyone will go out of jobs..

The cost barrier for custom models has effectively collapsed. $13.99 to fine-tune something production-usable is wild when you think about where this was even two years ago. The interesting next question is inference cost at scale. Training is a one-time expense, but serving a custom 9B model to real users adds up fast. That's where architecture choices around quantization and runtime optimization start mattering more than the training itself.

I pay Google $13.99 CAD to train a 9B LLM model on A100 80GB GPU. It takes: > 10 minutes to step notebook > 7 hours to train the model > 1.5 hour for eval testing > 1.25 hours for validation testing > 30 minutes for GGUF/MLX conversion Overnight, I run codex (with computer use chrome extension) on new notebook. In the morning I get a new custom trained model. It's not hard to train SLMs anymore. Wake up.

This is the right framing. The bottleneck for AI adoption at most companies isn't model capability. It's the gap between what models can do and what non-technical employees can actually set up and use on their own. Building the harness internally means you control the integration surface and the trust boundary. That matters a lot when you're connecting AI to internal tools with real financial data. Smart move to treat it as infrastructure rather than a vendor problem.

99% of Ramp uses ai daily. but we noticed most people were stuck — not because the models weren't good enough, but because the setup was too painful and unintuitive for most. terminal configs, mcp servers, everyone figuring it out alone. so we built Glass. every employee gets a fully configured ai workspace on day one — integrations connected via sso, a marketplace of 350+ reusable skills built by colleagues, persistent memory, scheduled automations. when one person on a team figures out a better workflow, everyone on that team gets it and gets more productive. the companies that make every employee effective with ai will compound advantages their competitors can't match. most are waiting for vendors to solve this. we decided to own it.

I'd push back gently here. The models can write code that looks performance optimized. Actually profiling it under production load with real memory pressure and contention is a different story entirely. What's getting commoditized is the mechanical work. But the judgment calls still separate great engineers from good ones. Knowing when not to optimize, when to accept tech debt, when a system needs a full redesign rather than another patch. That's the work that actually matters.

Good software engineering is no longer really impressive. The models can write performance optimized code. They can do on-call, they can spin up infrastructure. It's hard to do something impressive anymore

This is the right framing. The API surface is becoming the product, not the UI. Software that was designed for humans clicking buttons is fundamentally wrong for a world where agents are the primary consumers. Clean, well-typed APIs with predictable behavior become the competitive moat. From the engineering side, this is why I think strongly typed interfaces matter more than ever. When an agent calls your API, there's no human to interpret a vague error message. The contract has to be explicit, the errors recoverable, and the behavior deterministic. That's where Rust-style type safety shines.

“We’ve also been moving off legacy systems with poor, slow, outdated, and inconsistent APIs.” If you’re building software that can’t work fully headlessly in a way that agents want to use, you’re not prepared for what the future of software is going to look like. Agents will use software 100X more than people, and people will more and more interact with their data and workflows via agents across many different platforms. This is the real risk but also opportunity for platforms right now. Software doesn’t go away, but it becomes the guardrails and business logic for what agents are able to operate on. But if you can’t connect to wherever the agents want to do that work, you’re DOA.

Benchmarks measure capability in isolation. Production reliability is a completely different dimension. In my experience, the gap between benchmark performance and real-world usefulness is where most AI projects fail. The model that scores 5% lower but hallucinates 10x less is the one you actually ship with. This is why I build guard rails in strongly typed languages around any LLM output. The compiler catches the structural errors. The type system enforces contracts. You can't trust any model output blindly, but you can build systems that fail safely when the model gets it wrong.

DeepSeek models are heavily discounted and seems to outperform in benchmarks but in our work, we found them unusable. They hallucinate a lot and are not reliable. What’s your experience with these models?

The missing piece in this framework is that the Lone Genius still needs to understand systems deeply enough to direct AI effectively. You can't orchestrate agents building infrastructure if you don't understand why certain design decisions matter. The genius isn't replaced by AI, it's the filter that decides when AI output is good enough. In practice, the best version of both roles requires strong technical taste. The manager coordinating AI agents still needs to know when the output is subtly wrong. That's where deep domain expertise becomes more valuable, not less.

Bob McGrew has a framework I keep thinking about: in the AI future there are only two jobs. The Lone Genius and the Manager. That's it. Everything else gets absorbed. The Lone Genius is the person sitting alone at a computer, amplified 1000x by AI. One person with taste, vision, and relentless focus who can now do what used to take a team of 50. The Manager is the person who becomes CEO of their own "firm" where most of the employees are AI agents. They define the goals. They decide what matters. They coordinate. The AI does the execution. The Marxists will hear "two jobs" and panic. "What about everyone else?!" But here's what they're missing: AI doesn't shrink these two categories. It explodes them open. More people get to be geniuses. More people get to be managers. The barrier to entry for both just collapsed. What actually gets eliminated? David Graeber called them "bullshit jobs." Graeber was no libertarian! He inspired Occupy Wall Street. His words: "Huge swaths of people spend their entire working lives performing tasks they secretly believe don't really need to be performed. The moral and spiritual damage that comes from this situation is profound. It is a scar across our collective soul." Graeber said bullshit jobs are "a form of spiritual violence directed at the essence of what it means to be a human being." They induce "hopelessness, depression, and self-loathing." This is who the left should be fighting for. Not to preserve those jobs. To liberate people from them and give them better ones. The dirty secret of the modern economy: millions of people sit in roles so pointless that even they can't justify their existence. Compliance layers. Reporting layers. Coordination layers. Meeting-about-the-meeting layers. They know it's meaningless. It eats them alive. AI eats those layers. Good. That's a jailbreak. What I love about Bob's framework is where it points. The Lone Genius used to require a PhD, a lab, institutional backing. Now a 19-year-old with taste and Codex can ship what took a research team a year. The genius bottleneck was never talent. It was access. The Manager used to mean you needed to hire 50 people, raise money, build an org chart. Now you can orchestrate a fleet of AI agents from your laptop. The management bottleneck was never skill. It was capital. AI doesn't concentrate genius and management into fewer hands. It distributes them into more hands. The working class kid in West Virginia. The single mom in Ohio. The 55-year-old who got laid off and now builds software for the first time. Those are some of Bob's future geniuses and managers. The best founders I see at YC are already living this. They toggle between both modes in the same day. Morning: lone genius, creative insight, the thing nobody else sees. Afternoon: manager, spinning up agents, steering, shipping. The cycle time between genius and manager IS the new productivity metric. So when someone tells you AI means "only two jobs and everyone else starves," quote Graeber to them, they’ll get it. Graeber knew the real violence was making people do meaningless work and pretending it was dignity. AI ends that. More genius. More agency. Fewer spiritual prisons.

This matches what I'm seeing on my teams. When engineers ship 3x faster with AI tools, the bottleneck moves to product definition and design review. You need someone who can keep up with the pace of what's being built and make sure it all still tells a coherent story to users. The engineering leverage is real but it's unevenly distributed. AI coding tools work best on well-specified problems. The PM who can break ambiguous goals into precise specs becomes the force multiplier for the whole AI-augmented team.

Narrative violation: Anthropic's Head of Growth says we'll need more PMs, not fewer. "While PMs and designers are getting leverage from AI, engineering is getting the most leverage right now. If you think about a default team with 5 engineers, 1 designer, 1 PM—with Claude Code, that five engineers is like 2 to 3x'd, and the PMs and designers have also increased, but now they're managing what is effectively a much larger group of engineers. So though the head count and the org structure hasn't changed, you're now just dealing with a situation of maybe 15-20 engineers, 2 PMs, and 2 designers across the board. We're feeling PM and design is just being squeezed. Just absolutely squeezed. We just need to actually hire a ton more PMs."

There's a nuance here that gets lost. Being obsessed with the problem doesn't mean code quality stops mattering. It means you pick the right tool for the constraint you're solving. Sometimes that's an LLM. Sometimes that's a language with a strict type system that catches your mistakes before production does. The engineers I want on my teams are obsessed with the problem AND care deeply about how the solution is built. Those two things aren't in tension. The code is how you express your understanding of the problem. Sloppy code usually means sloppy thinking about the domain.

“I want people obsessed with the problem, not the code”

Turso is a great example of why Rust keeps winning infrastructure rewrites. The combination of memory safety, predictable performance, and first-class WASM compilation makes it uniquely suited for databases that need to run everywhere. You get the same binary running on a server, in a browser, and on-device. The async-first architecture choice matters too. Retrofitting async onto a C codebase is painful. Starting fresh in Rust with tokio means the concurrency model is correct by construction, not bolted on. That's the kind of advantage you only get from choosing the right foundation.

Turso is an incredible technical feat. A Rust rewrite of sqlite, with an async-first architecture, incoming support for concurrent writes, vector search, and browser / wasm support out of the box. I think this has a very good chance of being a foundational piece of infrastructure of the vibe-coding age. On-demand, sqlite-compatible global databases that can also run in-browser and on-device. The pace at which the project is evolving is most definitely *not normal*. @penberg and @glcst are built different. Demo: shell.turso.tech

This is exactly right. The speed constraint was always secondary to the complexity constraint. That's why I think languages with strong type systems matter more in the AI era, not less. The compiler managing complexity for you is the same principle Booch is describing here. In my experience with Rust, the ownership model forces you to confront complexity at design time rather than in production. AI can generate code faster, but the fundamental bottleneck remains whether humans can reason about what that code does. Tools that externalize complexity management to the compiler are more valuable than ever.

I reject your assertion. The entire field of software engineering evolved under the fundamental constraint of the human ability to manage complexity.

This captures the real risk of treating AI as a headcount reduction tool instead of a capability multiplier. The 3 engineers who stayed didn't need less management. They needed different management, someone focused on architecture decisions and system quality. From the engineering side, what I've seen work is using AI to raise the ceiling of what your existing team can ship. Not to shrink the team until the remaining people have no support structure left.

Engineering manager thought she cracked the code when she cut her team from 12 to 3 using Claude and Cursor last October MBA from Northwestern. 8 years climbing the ladder at a Series C logistics platform. Kept detailed metrics showing 340% productivity gains after the "AI transformation" Her remaining 3 seniors were shipping features faster than the old team of 12 ever did Got promoted to Director of Engineering in February. $220k to $285k salary bump. Stock options vested early. LinkedIn post about "leading through innovation" got 847 likes Presented the AI workflow playbook to the entire C-suite in March. Standing ovation from the CEO Yesterday she got invited to the same 30-minute "strategic realignment" meeting she used to schedule for others Her boss pulled up the same dashboard. Her director role automated by GPT-4 workflows. Her team management replaced by AI task routing The 3 engineers she kept? They're staying. They don't need a manager anymore She's getting 8 weeks severance while the company saves $285k annually on her salary The CEO just promoted one of her remaining engineers to "Technical Lead" at $180k Turns out middle management was just expensive overhead after all The irony is fucking beautiful

This matches what I see daily on my teams. The Rust compiler is essentially a pair programmer that gives the AI instant, precise feedback. No vague runtime crashes to interpret, just clear type errors and ownership violations. The interesting second-order effect is that Rust's strictness also makes AI-generated code easier to review. When the compiler enforces memory safety and lifetimes, the review can focus on architecture and logic instead of hunting for subtle bugs.

The best argument for Rust in 2026 is not memory safety or performance. It is that AI writes better Rust than it writes C++. The compiler feedback loop is so tight that models self-correct in real time. Every error message is a free training signal. Rust was accidentally designed for AI-assisted development 10 years before anyone knew that mattered.

Strongly agree. The best engineers I've worked with spend most of their time understanding the problem before writing any code. The code itself is just the artifact. In my experience leading AI-powered product teams, the engineers who thrive are the ones who can evaluate whether the AI's output actually solves the right problem. That judgment comes from years of navigating ambiguity, not from typing speed.

Worst AI take I keep seeing: "The job is no longer just writing code." The job of a software engineer was never just writing code. Software engineering has always been about understanding messy problems, asking the right questions, and making tradeoffs nobody warned you about. It's translating vague business requirements into something that actually works. It's convincing your team that, no, we shouldn't rewrite everything from scratch. It's debugging at 2am because a config change three sprints ago finally decided to cause problems. The code was always just the artefact. The job is everything around it. AI doesn't change that. If anything, it makes the "everything around it" part matter more. When generating code gets cheaper, the people who understand what to build, why to build it, what tradeoffs to make, and how to ship it reliably become even more valuable. So no, AI isn't transforming the role from "coder" to "thinker." The best engineers were always both.