The AI space right now is flat-out exhausting. Between the venture capital hype cycles, the nonstop tool fatigue, and tech “influencers” screaming about shiny new platforms every five seconds, the average person—whether a software dev, a business owner, or an everyday consumer—is completely overwhelmed. Most people tell me they have absolutely no idea what to use, how to use it, or what’s actually worth the monthly SaaS.
For those looking to leverage AI in their business, be it as a product they’ll use or something they’ll build for a client, I tell them the secret is to create compounding leverage through a brutal focus on architectural execution.
I don’t jump around between a million tools. A lot of what’s out there these days is just thin-wrapper AI platforms that were obsolete on launch day. Once I find a workflow that works, I stay with it and execute. My baseline day-to-day configuration is tight because it works:
Claude (Web and Desktop apps) for local file generation and server spins directly on my machine and reading Github repos
VS Code for making manual changes to files
Terminal for manual pushes and querying locally deployed files and databases
Claude Workbench for testing and strict output validation before deployment
But the absolute most underrated tool in the enterprise stack is Google Apps Script. It is absolutely staggering what you can run natively out of a basic spreadsheet. Most of my clients already operate within the Google Workspace ecosystem, so instead of forcing heavy software deployments or locking them into unpredictable usage-based pricing models, I write lightweight custom scripts that run within their existing framework for zero extra dollars across a variety of applications. I pipe a process into a script, connect it cleanly to a frontier model via an API call (or custom MCP depending on what the Script touches), and they get massive infrastructure automation without a bloated cloud invoice hitting their bank account at the end of each month.
Part of my own architectural execution is my personal AI agent, which I’ve been slowly building to handle work tasks for me. But one of the first things I did was build in a live demo function that I could trigger on client discovery calls to showcase what these systems can do. Explaining what background automation can achieve doesn’t work; clients need to see it chew through a task in real-time.
It works like this: I trigger the agent through Claude (I built a custom MCP for this) to draft a secure, single-use, tokenized link. I provide Claude with the client’s name, email, and website, and MDE (My Digital Employee) drafts an email for me. The client receives the email with the link, and when they click it, the background system activates a local server Python script, pulls prospect data, maps an industry scenario, pushes the code update through GitHub, and automatically deploys a clean “What If” landing page via Vercel. All the while, I can watch the agent’s progress on a custom PWA and receive Slack messages at the start and end of the run.
Oh, for context, the “What If” is a templated document that the agent customizes on each run, providing AI insights specific to the client’s industry and business. A little value-add for taking the time to speak with me.
When the agent is done, it emails the client a link to the freshly deployed page and a little something extra (more on that below).
The entire automated research, content writing and deployment pipeline runs ~2 minutes for roughly $1.25 in API tokens. Manually, that’s a 45-minute workflow for a human who has shit locked down. And if I had to train an employee to execute that exact task list, it would easily take a greenhorn an hour and a half.
But the real magic isn’t the speed or cost savings but the built-in reflection loop. I engineered the agent to critique its own performance at the end of every run and output a journal entry documenting its reasoning, which it adds as an additional link in its final email to the client.
When I first rolled this out, it started spitting out some bizarre self-improvement suggestions that would have completely tanked the core function over time. It was a stark reminder that stochastic systems will absolutely wander down a rabbit hole of hallucinations without ironclad boundaries.
To fix this, I built a dedicated database layer. Now, the agent logs three to five critiques per session. I can pull up the logs directly via a command-line interface in my terminal to review them. If a suggestion is trash, I delete it. On the next execution, the agent checks the validated database records and applies those specific corrections to refine its output. I only had to delete a couple of bad self-suggestions before the new logic loop took hold, and it stopped suggesting weird shit. Now it makes genuinely useful self-reflections that create a positive feedback loop.
My Next Architecture Step: I am embedding a bidirectional Slack loop. The agent will ping me its logged optimizations directly in a channel, and I can edit, approve, or rewrite its internal database logic via a simple chat message without ever manually touching the backend code.
There is a massive, unannounced drift away from cloud architecture right now, driven entirely by two things: runaway cloud costs and extreme data privacy anxiety.
I consult with lawyers, accountants, and M&A specialists. These folks are legitimately worried. They see peers attempting to “vibe-code” workflows, and suddenly they realize they are streaming highly sensitive, non-public corporate data straight through external corporate servers. Frontier cloud security protocols are decent, but data leaks and active threat vectors are a permanent reality. If an M&A firm leaks a client’s acquisition blueprint, they are legally and financially dead in the water.
The ultimate solution for small- to medium-sized enterprises is locally deployed compute, such as MDE. You buy local hardware—like a Mac Studio packed with 128GB of unified RAM—and run optimized local models or local Whisper frameworks completely offline. The hardware capability is mind-blowing, the data never leaves the physical building, the security posture is airtight, and you completely eliminate the margin-crushing monthly token bills.
If you are building an AI software product right now that just slaps a clean user interface over a basic OpenAI or Anthropic API, you don’t have a business. All you have is a feature that will quickly get swallowed whole by the next model update. It's only a matter of time before the public realizes: “I already pay for Claude; I’ll just ask Claude directly.”
Your only real moat in software engineering today comes down to two architectural priorities:
Deep Context and Memory Scaffolding: Building sophisticated custom database retrieval structures that manage short- and long-term state flawlessly.
Hyper-Opinionated Logic Triggers: Enforcing strict deterministic guardrails to make sure the model handles data precisely how you want it to, without wandering off into creative nonsense.
I learned this lesson clearly when I built MoveSmart, a platform that helps people relocate abroad. During development, I ran into massive, systemic biases deeply baked into the foundational frontier models. No matter how varied the test inputs were, the model would get stuck in a loop and continuously recommend the exact same six to eight countries—it was obsessed with recommending Portugal to everyone. I had to write incredibly intense, aggressive prompt engineering constraints to smash that internal bias and force objective country matching.
Furthermore, when I designed a conversational chat interface for it, the chat became brutally bland because the second I allowed the model to have “character” or speak in a loose, personable tone, it immediately blew past its constraints, drifted off the core data pipeline, and failed to hit the logic triggers required to generate the underlying country-matching report.
I recently migrated MoveSmart from Replit to a self-hosted setup, and now that it costs almost nothing to run, readdressing the chat UX is on my to-do list.
I look out my window in Belize, and I see a massive, hilarious contradiction to the AGI echo chamber. While tech social media circles argue endlessly over autonomous agents and spatial compute, the baseline reality of the developing world is entirely analog.
Everything here runs on physical paper. Cash is completely dominant. I am navigating the local residency and tax departments right now, and the infrastructure is literally rusted metal filing cabinets and boxes of paper stacked to the ceiling.
When these offices hit their data retention limits, they don’t upload archives to a server or click a delete button. They carry the cardboard boxes out to a ditch behind the building, throw them in, and literally light them on fire. That is their entire document disposal protocol.
Coming from a construction background, I'm not surprised. It anchors my view of operational systems. You cannot layer advanced automation over an infrastructure that hasn’t even accomplished basic digitization yet. The ultimate frontier market for software engineers isn’t chasing esoteric tech hype; it’s building the practical, gritty bridges that move real-world businesses from physical paper to cloud-native foundations.
Because of this rapid shift, the skills that will matter over the next ten years aren’t specific technical coding frameworks—the models are automating syntax entirely. The real, durable skills for the next generation are rooted entirely in:
High-Level Literacy: The sheer executive capacity to sit down, focus, and read dense model outputs critically to spot logical flaws or hidden assumptions.
Task Architecture: The ability to clearly define a structural problem and break it down into clean, modular components.
Creative Problem Solving: Grounded execution and adaptability over relying on institutional credentials or expensive degrees.
I have a four-year-old and a five-year-old. I don’t care if they learn specific software suites that will be obsolete by the time they grow up. Right now, I keep them building constantly with Lego. It’s spatial, it’s structural, it requires strict problem-solving, and it builds the foundational engineering mindsets that no model can replace.
And to everyone else wondering where this all ends, I say keep building, keep reading, and stay grounded in the baseline reality of how the physical world actually operates.
Happy ASDing!
Comments
Nothing yet. Say the first thing.
Sign in to join the conversation.