Ernest Mueller

See how Forward Deployed Engineers have helped close the gap on implementing AI agents leading to a 800% spike in FDE job postings between Jan. and Sep. 2025, according to Indeed and the Financial Times:

3

I’ve been hearing some spicy takes on vibe coding lately and one of them actually stopped me mid-scroll. “Vibe coding is just like Python. It’s another abstraction layer built on the foundation those before us laid down.” Is that right? Could it really be that simple? When Python emerged, purists pushed back. “Real engineers write C.” “You don’t know what’s happening under the hood.” Sound familiar? But is abstraction just how our industry evolves? Is every layer we add a force multiplier, letting engineers operate at a higher level, solve bigger problems, and move faster? Maybe vibe coding isn’t the death of engineering craft. Maybe it’s just the next rung on the ladder? Did the floor disappear when Python took off? You still needed to understand systems, architecture, and failure modes. Will the same hold true here? So the question isn’t “should I use it?”, it’s “are you building the judgment to use it well?” Curious where you all stand. Are you embracing vibe coding, or still skeptical? Drop your take below. 👇 #NetDevOps #NetworkAutomation #VibeCoding #AI #InfrastructureAsCode #Engineering

11

5 Comments

I’m seeing teams stuck between first-party vs. third-party/ cloud-integrated storage. This piece by TechArena.ai Voice of Innovation Gina Rosenthal lays out the trade-offs clearly: control and locality on-prem, scale and simplicity in first-party cloud services—plus what “cloud-integrated” really means. If you’re mapping a 2026 storage refresh, give this a look and pressure-test your assumptions: Link in comments. #DigitalSunshine

2

1 Comment

I have been using ralph loops to autonomously work through a list of well defined tasks. The challenge that I've had is none of the tooling out there was exactly what I was looking for. Existing ralph implementations have issues like context pollution from auto-compaction with the claude recommended plugin. Other implementations out there are needlessly complex and have weak cost management controls. So I built Ralph Simple Smart (https://lnkd.in/eg5Vr6Nk), a lightweight bash implementation that fixes these problems. It starts a fresh context for each task instead of relying on compaction, supports Claude's auto permission mode instead of requiring --dangerously-skip-permissions, and can cap usage based on your actual session limits so you don't blow through your token budget. The whole thing is around 200 lines of bash. No monitoring dashboards, no orchestrators, no opinionated workflows. Just a loop that picks up tasks, runs Claude, and stops when the work is done or your usage limit is hit. Simple and effective.

10

Context bloat is a silent tax on your Cursor and Claude Code. 💸 When an MCP tool dumps 10,000 tokens of irrelevant JSON blobs into your chat, it burns budget, eats your context window, and distracts the LLM. Introducing MCP+: https://lnkd.in/giEcc26f 🚀 MCP+ is a server-agnostic, agent-agnostic, task-agnostic post-processing layer that wraps around your MCP clients as a protective filter 🛡️ — requiring zero changes to your existing agent logic. ✨ What it does: • Offload messy “analyze the tool output” to a cheaper model  • Preserve your premium Claude Opus 4.5 context for what actually matters — writing code  • Reduce inference cost by up to 75% — while maintaining the performance Less noise. Lower cost. More signal where it counts. 🎬 Watch the demo: https://lnkd.in/gGm536pb

60

Reconsidering MariaDB’s Role in the Modern Database Landscape (db-engines) MariaDB stands alone as the only open source database backed by a Foundation whose sole mission is the database. No corporate detours into AI data centers or unrelated product lines — just a clear, focused commitment to MariaDB and the community that depends on it. #MariaDB #MariaDBFoundation #OpenSource #OpenSourceDatabase #DatabaseGovernance #DatabaseContinuity #MySQLEcosystem #OperationalExcellence #DataInfrastructure #MySQL #PostgreSQL

3

Git worktrees are the new hotness now that agents can work on parallel instances of your codebase. What they don’t solve is the port conflict problem, that’s where aspire run/start —isolated comes! Inspired by work from Tamir Dresher https://lnkd.in/gWpaa_hN #aspiredev

248

16 Comments

Think of CIEM integrations like a universal translator for your cloud: because AWS, Azure, and GCP definitely aren't speaking the same language when it comes to permissions. 🌍🗣️ #CloudSecurity #IdentityAccessManagement #CIEM #ZeroTrust #CyberSecurity #MultiCloud #DevSecOps

1

Most "unreliable agent" problems aren't reliability problems. They're architecture problems wearing a prompt costume. I call this Prompt Creep. It starts innocently. You tell an LLM agent to check if a file exists before acting on it. Works. You add a branching condition. Works. A loop over a diff. Works. Then one day a step gets skipped, and the fix is to add emphasis: IMPORTANT: you MUST run validation BEFORE making any edits. That's the tell. 🚩 When you're adding caps to compensate for unreliability, you're working against the grain of the tool. A coded if statement doesn't need to be told it's important. The post covers: → Why this fails (Sinha et al.'s long-horizon execution paper has the cleanest data — small per-step errors compound exponentially, and models self-condition on their own mistakes) → The orchestrator pattern: code owns control flow, LLM owns judgment, with a worked code-review example → How orchestrators differ from agent harnesses like Codex, Claude Code, and Goose: and why the difference matters more when there's no human in the loop → A 2×2 for placing your own system: control flow (code vs model) crossed with human involvement (supervised vs autonomous). The autonomous-harness quadrant is where things get expensive. If you've ever bolded a word in a system prompt hoping it would land, this one's for you. 🔗 https://lnkd.in/dt4YJRfv

10

3 Comments

I don't allow my teams to use the AWS SDK in application code. Ever. This might sound extreme, but it's essentially Open/Closed Principle thinking applied to system architecture. Every direct SDK call tightly couples your software to the underlying cloud provider. The Open/Closed Principle states that software entities should be **open for extension, closed for modification**. In practice at the system level, this means isolating change to extension points rather than core logic. **Here's my approach:** Use Kubernetes as the abstraction layer. Applications know nothing about cloud APIs—or even Kubernetes APIs. Need secrets? They're injected as environment variables. Your app never knows if they came from AWS Secrets Manager, Vault, or a config file. Need storage? Volumes are mounted at deployment time. Your app just reads from `/data`—it doesn't care if that's EBS, GCP disks, or local storage. Need messaging? Standard interfaces, swappable backends. Terraform and Helm codify all this infrastructure-as-code, sitting right alongside the app repos. **The practical benefit:** When we want to switch from AWS to GCP, that's a plugin configuration change, not a code modification. The applications remain completely unchanged. Yes, this binds us to Kubernetes. But here's the real benefit: when AWS updates their SDK or changes endpoints—which happens constantly—I update one plugin configuration, not dozens of applications. Commercial vs GovCloud deployments? Different regions? API versioning? All handled at the infrastructure layer, once. Teams using direct SDK imports are updating dependencies across their entire codebase every few months. I'd rather work at the plugin infrastructure layer one time for all apps than update SDK versions many times everywhere. Build systems that bend, don't break, when requirements change. Open/Closed thinking isn't just about clean code—it's about architectural independence. **Questions for you:** - Do you abstract cloud APIs or call them directly from application code? - What's your experience with Kubernetes as a vendor abstraction layer? - Where do you see the biggest OCP violations in modern cloud architectures? *Day 2 of 5: SOLID principles for cloud architecture. Tomorrow: Liskov Substitution Principle.*

269

112 Comments

"I hate documentation." - Almost every engineer and architect prior to GPT The truth is, the laborious nature of documentation made me think I hated defining requirements. But after using GitHub Copilot for a while, I've realized something: I actually don't mind defining requirements, building specs, planning, generating user stories, and tasks. It turns out, I just hated converting my thoughts into well-formatted documents. Now I'm really enjoying the process of writing out specs in my natural language (capitalizing only when i feel like it 😊) and watching my brain dumps turn into well-structured documentation. This includes everything from user stories and dependencies to edge cases, functional requirements, data-models, and checklists. The tool that sparked this revolution for me is GitHub Spec Kit. If you haven't seen it, you need to check it out. If you're skilled enough to install these few things on your PC, you can truly build anything: VSCode GitHub Copilot git python (or your preferred language) uv I'm creating a YouTube series where I build cool things with Spec Kit, so stay tuned. I'll be building backend services, AI agents and even some video games! Let me know if you want to get updates on this. Another tip: Record yourself in a meeting (just ramble everything that you can think of and don't worry about long pauses while you're thinking), get the transcript, run that through GPT to condense it into a spec and feed that to Spec Kit.

19

11 Comments

Sometimes, the copy generated by Claude is bad and largely unusable, but ­— that still broke through the writer's block and empty page problem by showing me a version of my text I did not want. Similarly, plans aren't made to be met. Their main utility is as anchors to compare our actual progress to instead of free-wheeling. We understand reality through differentiation. (G. Spencer-Brown recognized this in the 1960s.)

7

1 Comment

I started a post yesterday, that from my experience, producing production software was obvious, about rule of 5 data types. There is one thing I am 100% adamant about, and one thing that I was surprised on the pushback. First, what I am an adamant about. Never, ever, use raw pointers! I mean, do not do this. There is no safe way of ever using a raw pointer. ` void f(Type* a) { if (a != nullptr) a->func(); } ` ^--- There is absolutely no guarantee that 'a' will not crash in production. The C/C++ language does not provide this, so you cannot assume it. Just don't do it. Here are better solutions: ` void f(Type& a) { a.func(); } ` Now, if you have to allocate memory, use `std::shared_ptr`, why? because you don't have to worry about ownership... And the cost only happens at assignment..., so don't pass by value, just like you don't pass vectors by value! The pointer stays live as long as someone owns the pointed-to data. The people who brought up concerns, brought up valid concerns, but those are optimizations, not how to write safe software by default. I think the misunderstanding is theoretical and not due to understanding of the implementation (which btw plagues the AI world immensely....). Go to fundamentals, how is std::shared_ptr implemented at its most basic level, as 'B'? ` template<typename T> class B{   T* ptr;   std::atomic<int>* ref_count;    public:   explicit B(T* p = nullptr) : ptr(p), ref_count(nullptr) {     if (ptr) {       ref_count = new std::atomic<int>(1);     }   }      B(const B& other)      : ptr(other.ptr), ref_count(other.ref_count) {     if (ref_count) {       ref_count->fetch_add(1); // Atomic increment     }   }      ~B() {     if (ref_count && ref_count->fetch_sub(1) == 1) { // Returns old value       delete ptr;       delete ref_count;     }   }      B& operator=(const B& other) {     if (this != &other) {       if (ref_count && ref_count->fetch_sub(1) == 1) {         delete ptr;         delete ref_count;       }       ptr = other.ptr;       ref_count = other.ref_count;       if (ref_count) {         ref_count->fetch_add(1);       }     }     return *this;   } }; ` unique_ptr can be simplified to: ` template<typename T> class A{   T* ptr; public:   explicit A(T* p = nullptr) : ptr(p) {}      ~A() { delete ptr; }      A(A&& other) noexcept : ptr(other.ptr) {     other.ptr = nullptr;   }      A& operator=(A&& other) noexcept {     if (this != &other) {       delete ptr;       ptr = other.ptr;       other.ptr = nullptr;     }     return *this;   }   A(const A&) = delete;   A& operator=(A&) = delete; }; ` unique_ptr is slightly less memory at allocation/deallocation, and disallows copies. That is it! If you don't copy your shared pointers(like you don't copy std::vectors!), then the penalty is miniscule! I appreciate the feedback of experts and teachers like Vittorio Romeo, Valentyn Mudryk, @Jose Sa, and others for discussing the ways to optimize! However, std::shared_ptr gives you everything you need by default!

28

43 Comments

I lost an hour of research work last week. Not because my computer crashed. Not because I forgot to save. But because I was moving a report from the Gemini app into my terminal workflow—copying, pasting, reformatting—and somewhere in that dance, I lost everything. This is the kind of friction we tolerate every day: powerful AI tools trapped in browser tabs, disconnected from where we actually work. Here's the thing: I live in the terminal. My notes are markdown. My drafts are plain text. My entire development environment assumes I'm working with files and command-line tools. Every time I jump to a browser to use a feature I need, I'm fighting against the grain of everything else I do. So I did what frustrated engineers do. I built the tool I needed. What it does: A Gemini CLI extension that brings deep research directly into the terminal. You kick off a research query, it runs in the background for 20 minutes (or as long as it needs), and a comprehensive markdown report with citations appears in your filesystem. No browser tabs. No context switching. No lost work. It turns out, when you build software for an audience of one, you get exactly what you need. No feature bloat. No compromises. Just the tool that solves your specific problem.  I wrote about the whole experience, from losing work to shipping the extension, in my latest post. It's the second in my "Bringing X to the Terminal" series, about making AI capabilities accessible where developers actually work. 📝 Read it: https://lnkd.in/gZ9pVMRS 💻 Try it: https://lnkd.in/gYGRxbX3 What tools have you built just for yourself? #DeveloperTools #AI #PersonalSoftware #TerminalLife #GeminiCLI #DevProductivity #OpenSource

67

8 Comments

Today, Claude taught me about websocat (think curl, but for Web Sockets). I asked it to debug something, it reached for websocat (which I didn't have installed, but researched) and then fell back to using node with the websocket module library. No good deed goes unpunished, now Claude also had to implement a websocat shim for SLICC, so that you'll be able to work with Web Sockets more easily.

18

3 Comments

2025 was the year to experiment with AI development tools. 2026 is the year to decide who you are as a team. If you are still running pilots and calling everything a POC, you are signaling that AI is a side project. Your competitors have already embedded it into their SDLC, governance, and review processes. For them, AI is no longer a playground; it is physical infrastructure. This also means vendor clarity matters. If you, as an AI tool vendor, have confusing branding, overlapping products, and no model ownership, you are signaling marketing issues and a lack of product vision. You are projecting structural weakness. When the model and the tool are tightly integrated, innovation cycles accelerate, and developer trust is built. Vendor product confusion leads to customer confusion and turns engineers off from your products. Forcing your developers to use your confusing tools signals structural weakness, not a product vision. As a vendor, you end up producing demos and untrusted POCs. As a vendor with a confusing roadmap, you are underwriting someone else's lead.

17