DEV Community: Robort Gabriel

I Built a 4-Agent Claude Code Pipeline That Ships Code While I Sleep

Robort Gabriel — Fri, 24 Jul 2026 18:59:44 +0000

I Built a 4-Agent Claude Code Pipeline That Ships Code While I Sleep

You type one command before bed. By morning: a written spec, the actual code, tests that already ran, and a SHIP, NEEDS WORK, or BLOCK verdict waiting for you. That's the whole idea behind a Claude Code agent pipeline, and once it's running it changes how you think about using AI to write software.

The Loop Most People Get Stuck In

You ask Claude to plan, it plans. You ask it to write the code, it writes the code. You ask it to test, it tests. Somewhere in there you're still the one carrying context from step to step, still the one deciding what happens next. The moment you stop typing, the whole thing stops moving. That's not a prompting problem, it's an architecture problem. The fix is four specialist agents that hand off to each other automatically, triggered by one command.

The Handoff: A Shared Folder, Not a Shared Context Window

The part that makes this actually reliable is simple. Each agent writes its output to a file in a .pipeline/ folder, and the next agent reads that file to pick up exactly where the last one stopped.

.pipeline/spec.md          <- Planner writes
.pipeline/changes.md       <- Coder writes
.pipeline/test-results.md  <- Tester writes
.pipeline/review.md        <- Reviewer writes

One folder, four files. If something breaks, you open any one of them and see exactly what that agent had to work with.

The Four Agents

Each one is a Claude Code subagent: a narrow job, its own isolated context, one output.

Planner never writes code. It reads the codebase, understands how things are actually built, and writes a spec: which files change, what functions are needed, edge cases, open questions.

Coder reads that spec and builds exactly what it says, following the patterns already in the codebase. Keeping it scoped this tightly is what stops the "helpful" scope creep where an agent quietly rewrites things you never asked it to touch.

Tester reads what the Coder built and writes tests for the normal case, the edge cases the Planner flagged, and at least one failure case, then actually runs them. If something fails, it stops and reports rather than trying to patch the code itself.

Reviewer is the final gate. It reads the spec, the changes, and the test results, runs a diff, and gives one of three verdicts: SHIP, NEEDS WORK, or BLOCK. It's read-only by design. It can flag a problem but not fix it, which keeps one agent from writing code and grading its own homework.

Wiring It to One Command

Wrap all four in an orchestrator, saved as a project skill (.claude/skills/ship/SKILL.md). Then type:

/ship add rate limiting to the login endpoint

The orchestrator sends your request to the Planner, waits for the spec, passes it to the Coder, waits for the code, passes it to the Tester, waits for results, passes everything to the Reviewer, and shows you the final verdict. One line in, four agents run in sequence, one full feature out. It's the same pattern Anthropic describes for chaining subagents in sequence: specialized workers, each with their own context, tied together by an orchestrating instruction set.

What Actually Changes

The shift here isn't "AI writes code faster." It's that you stop being the one who manually connects plan to code to test to review. You become the person who reviews finished work and decides what ships. The first time /ship handed me back a tested feature with a clear verdict waiting for me, it changed how I scheduled my day. I stopped blocking time to babysit the AI and started blocking time to review what already got done.

Try It Yourself

I wrote up the full walkthrough with all five files ready to go, the ship.md orchestrator plus the four agent configs, drop-in for .claude/skills/ and .claude/agents/: How to Build a 4-Agent Claude Code Pipeline That Ships While You Sleep. Grab the free kit there, adjust the paths and constraints to match your own repo, and you'll have your own /ship command running in about ten minutes.

Anthropic Academy: Free Courses on the Claude API, MCP, and Claude Code (With Certificates)

Robort Gabriel — Tue, 21 Jul 2026 08:15:35 +0000

Anthropic has a full training catalog sitting online right now, 18+ courses, all free, all self-paced, each one ending with a certificate you can put on LinkedIn. A Reddit post sharing the catalog pulled 2,665 upvotes on r/ClaudeAI. Most developers who use Claude daily have never heard of it.

It's called Anthropic Academy, hosted on Skilljar (the same LMS Stripe and Twilio use for training). No credit card, no Anthropic account required to enroll, just a free Skilljar account. I went through the catalog and pulled out what actually matters if you're building with Claude rather than just chatting with it.

The developer-relevant tracks

The catalog spans beginner to enterprise, but four courses matter most if you're writing code against Claude:

Building with the Claude API walks through getting an API key, making your first call, structuring conversations, and handling outputs. It's the fastest on-ramp if you haven't touched the API yet. I wrote a deeper follow-up on connecting Claude to your own apps via the API if you want the next step after this course.

Model Context Protocol (MCP) covers how Claude connects to external tools: databases, file systems, business apps, whatever you need it to actually act on instead of just describe. One developer who'd completed 10 of the 18 courses said the MCP material was "definitely juice that's worth the squeeze, particularly learning STDIO and StreamableHTTP transport protocols." That tracks with how central MCP has become to any real Claude integration work.

Claude Code is the terminal-based coding tool course. It covers writing and reviewing code, working inside projects, and using Claude as an actual coding assistant rather than a chat window. If your team is adopting Claude Code, this is the fastest shared reference point to point new hires at.

Introduction to Agent Skills covers Anthropic's Agent Skills framework, reusable capability files that give Claude specialized knowledge and tools. Aimed at people building with Claude Code or the API who want more task-specific setups rather than one giant system prompt.

There's also a non-technical Claude 101 course and an AI Fluency track built with professors Joseph Feller and Rick Dakan, useful if you need to onboard non-technical teammates without writing your own internal training doc.

Is there a paid credential too?

Yes. On March 12, 2026, Anthropic launched the Claude Certified Architect (CCA), a proctored 60-question exam testing whether you can design and ship production-grade Claude applications at enterprise scale. Closed-book, no AI assistance, and it covers agentic architecture, MCP integration, Claude Code workflows, and prompt engineering.

The CCA is separate from the free Skilljar courses, it's the credential to aim for if you're building Claude commercially and want something that proves it. For most people, though, the free courses cover what you need to get productive.

Where to start, based on what you're doing

New to the API entirely: Building with the Claude API first, then layer on MCP once you have a working integration.
Already building agents or tool-using workflows: Go straight to MCP, then Agent Skills.
Rolling Claude Code out to a team: Take the Claude Code course yourself first, then use it as the shared reference when onboarding others.
Managing AI adoption, not writing the code: Claude 101 followed by AI Fluency.

Signing up

Go to anthropic.skilljar.com
Create a free Skilljar account
Pick a course and enroll
Work through it at your own pace
Pass the final assessment
Get your certificate, share it on LinkedIn

No Claude account required to take the courses, though you'll want one at claude.ai if you want to practice what you're learning as you go.

Worth the time?

The MCP and Claude Code courses go deep enough to be genuinely useful even if you've already been building with Claude for a while, they're not just marketing dressed up as training. The catalog is also still growing: 15 courses at launch in March 2026, past 18 by May. Anthropic is clearly treating this as a real product, not a one-off.

If you're integrating Claude into anything, there's a shareable credential sitting in that catalog that costs you nothing but time. I put together a recommended course order by goal (beginner, business, developer) if you want a roadmap instead of scrolling the full catalog yourself.

Zo Computer: A Cloud Server You Control by Just Talking to It

Robort Gabriel — Sun, 19 Jul 2026 13:57:35 +0000

I have spun up plenty of cloud boxes over the years, and every single one wanted the same thing from me first: SSH keys, a config file, a package manager, and patience. Zo Computer skips all of that. It is a real Linux server with an AI assistant wired directly into it, and you drive the whole thing through plain English chat.

I have been using it for a few months now to run content pipelines, host small sites, and automate the boring parts of my workflow. Here is what it actually is, how it is different from a chatbot, and what to try first if you spin one up.

What you are actually renting

Under the hood, a Zo is a Linux server. You get a real filesystem, a real terminal, and root access if you want it. The part that changes everything is that an AI agent sits on top, and it can read files, run shell commands, hit APIs, host services, and talk back to you over chat, email, SMS, or Telegram. You describe a task in plain language, and the agent executes it on the server directly, no code required unless you want to write some.

By default it runs on Claude, built by Anthropic, but you can wire in your own API keys for OpenAI, Gemini, OpenRouter, Groq, and others from the settings page. That matters if you already have a model preference or want to control cost per task.

The model settings panel: bring your own keys, or use the built-in Claude access.

Why this is not just "a chatbot with extra steps"

A normal LLM chat window is stateless in practice. You ask, it answers, the tab closes, the context is gone. Zo Computer flips that model. The agent runs against a persistent server, so it has:

A real filesystem it can read from and write to across sessions
Scheduled automations that fire on a cron-style timer without you present
Hosted services, meaning it can stand up a web page or API with a public URL
Memory of your projects and preferences that carries across conversations, not just within one thread

That combination is the actual unlock. An LLM that can only talk to you inside a chat window can help you think. An LLM that owns a server can go do the work and check back in. I go deeper into building recurring workflows on top of this in my guide to setting up automations on Zo Computer, if you want to see what a scheduled agent job looks like end to end.

Getting a server running

Sign-up is free, no card required, at zocomputer.com. The free tier gives you a daily usage allowance and the server sleeps when idle (it wakes on demand). Paid tiers keep it always-on and add custom domains plus higher credit limits.

Once you are in, your instance lives at {your-handle}.zo.computer, reachable from the web app, desktop app, or chat channels. There is nothing to provision. You just start typing.

Things worth trying in your first session

A few tasks that show the range of what the agent can actually execute on the server, not just describe:

Ship a page without touching a build tool.

Create a simple landing page for my [business type].
Make it clean and professional.

This gets built and published to your zo.space subdomain in minutes.

Wire up a cron-style job in plain English.

Check my Gmail for unread important emails, summarize the
top 3, and send me a Telegram message. Run this every day at 7am.

No crontab syntax, no deploy step. You describe the schedule and the trigger, and the automation panel handles the rest.

Package a repeatable workflow as a named skill.
Skills are reusable instruction sets you save once and invoke by name later, similar in spirit to a slash command backed by a prompt file. Define one for something you do often, like drafting a content idea from a topic, and it becomes a one-line invocation from then on.

Open the actual terminal.
If you want to verify what the agent is doing, or just poke around yourself, there is a real terminal panel backed by the same Linux box. Check disk usage, list processes, install a package. It is optional, but it is there, and it is not a sandboxed toy shell.

Where this fits

If you are the kind of developer who already scripts your own automations with cron and a VPS, Zo Computer is not replacing your stack, it is collapsing the setup cost. The interesting part is not that an AI can write code, it is that the AI has a server to run that code on, persistently, with memory of what it did last time. I have a full walkthrough of the sign-up and first-session flow, along with a companion starter guide you can download, over on the original write-up if you want the extended version with more setup detail.

A Developer's Quick-Start Guide to Claude AI

Robort Gabriel — Sun, 19 Jul 2026 09:13:00 +0000

Every new tool has the same fifteen minutes of friction: you open it, stare at an empty input, and have no idea what the "correct" first move is. Claude is no different. The blank text box gives you zero hints about the features underneath it, so most people either type something vague or bounce entirely.

None of that is because Claude is hard to use. It is because nobody hands you the setup checklist. Here is mine, the version I wish I had before my first session. You can get through all of it in under 30 minutes.

What Claude Actually Is

Claude is Anthropic's conversational AI assistant, built for writing, research, document analysis, and general problem-solving through plain-English chat. The thing that separates it from a lot of the tools in this space is how it holds up over long, multi-step tasks: it can read a full document and summarize it, draft an entire proposal, or turn a rough idea into finished copy without losing the thread halfway through. If you're deciding between Claude and other assistants, I compared them directly in Claude AI vs ChatGPT: Which One Should You Use in 2026?.

1. Set Up Your Account

Free — daily usage cap, enough to learn the tool
Pro — higher usage limits, access to the most capable models, full feature set including Projects
Max — highest limits, built for heavy day-to-day use

Full pricing is on Claude's pricing page. Start free. Upgrade once you actually hit the ceiling, not before. There are also native apps: desktop, iPhone, and Android.

2. Learn the Four Zones of the UI

Chat window — where the conversation happens
Left sidebar — conversation history and Projects
Artifacts panel — a side window that opens whenever Claude outputs a document, chart, or working app
Attachment button — the paperclip icon for file uploads

That's the whole surface area. Nothing is buried.

3. Prompting Is Just a Format, Not a Skill

The single biggest gap between a mediocre response and a great one is specificity. "Help me with marketing" gives the model almost nothing to anchor on. Use this shape instead:

[Role] + [Task] + [Details]

Compare "write me an email" to:

"You are a professional business writer. Write a short email to a client letting them know a project will be delayed by one week. Keep the tone apologetic but confident. The project is a website redesign."

Same request, radically different output. Adding a role and concrete constraints is the difference between briefing a stranger and briefing a colleague who already has context. I go deeper on this, including a full 5-element formula with before/after examples, in How to Write Claude AI Prompts That Actually Get Results.

4. Projects: Persistent Context Instead of Re-Explaining Yourself

By default, Claude forgets everything the moment a conversation ends. Projects fix that — think of a Project as a scoped workspace with its own standing instructions and knowledge base, closer to a repo-level config file than a chat thread.

Set it up once:

Open "Projects" in the sidebar, or go to claude.ai/projects
Click "New Project"
Name it, then add your instructions to the knowledge base — e.g. "Always write in a casual, friendly tone. Short paragraphs. Audience is small business owners."
Every chat inside that Project now inherits those instructions automatically

No more re-pasting your style guide into every new thread. I cover full setup, plus five ready-to-use instruction templates for different business types, in the Claude AI Projects guide.

5. Artifacts: Output That Lives Outside the Chat Log

Artifacts are Claude's way of separating "the answer" from "the conversation." Ask for a document, a small app, or a chart, and instead of dumping it inline, Claude opens it in a dedicated panel you can view, edit, copy, or export on its own.

A few things that trigger it:

"Write a one-page business summary" → a formatted doc ready to paste into Word
"Build a simple HTML calculator" → working, downloadable code
"Create a bar chart from these monthly sales figures" → an interactive chart

Available across Free, Pro, Max, Team, and Enterprise, and it works on mobile too.

6. Feed It Files Directly

Click the paperclip, upload a PDF, spreadsheet, or image, and query it directly:

"Summarize this PDF in 5 bullet points."
"Find inconsistencies in this spreadsheet."
"Rewrite the intro of this document to be more engaging."

This is the highest-leverage feature for anyone drowning in long documents. Instead of reading a 40-page contract end to end, upload it and ask for exactly what you need pulled out.

Try It Yourself

You've got the account, the interface, the prompt format, and the two features (Projects, Artifacts) that make Claude usable long-term instead of a one-off novelty. Open a chat and run this:

"Act as a business advisor. Give me 5 specific ways a [your type of business] can save time this week using AI tools."

See what comes back, then iterate. For the full walkthrough with screenshots and a free starter prompt kit, the original writeup is here: How to Start Using Claude AI as a Complete Beginner.

AI Agents: Automate 80% of Support (Case Study)

Robort Gabriel — Sun, 11 Jan 2026 17:57:30 +0000

A fast-growing SaaS company came to us with a super common problem: support was growing faster than their team could keep up. First replies dragged. Agents kept typing the same answers like it was Groundhog Day. A few truly urgent tickets even got buried in the backlog, which is basically every support lead’s nightmare.

We fixed it by rolling out AI Agents, and not the “random chatbot that says sorry a lot” kind. This was a set of focused automations that could triage tickets, draft solid replies, route weird edge cases to humans, and learn from what happened next. The end result: 80% of incoming tickets were handled end-to-end with human review only when it actually mattered, while customer satisfaction stayed steady and response times dropped.

The goal wasn’t to “replace support.” It was to remove repetitive work, tighten quality, and let humans focus on the hardest 20%.

The Starting Point: Why the Support Team Was Overwhelmed

Before we built anything, we did the unglamorous part: we mapped the real workflow. The client’s support inbox was the usual mixed bag, billing questions, password resets, basic “how do I” requests, bug reports, and those account-specific issues that require detective work. A small team was triaging everything by hand, then digging through docs or old tickets to reply. That created the kind of bottleneck you can predict like Monday morning traffic, because the same ticket types showed up every day.

The biggest issue wasn’t the raw ticket count. It was context switching. One agent might bounce from refunds to API errors to onboarding questions in a single hour. That’s how mistakes sneak in. It also slows everything down, even if the team is working hard.

We also saw inconsistent tone and policy enforcement. Two agents could explain the same rule in totally different ways, and customers would (fairly) wonder if the company was making it up as it went.

What we measured first (baseline)

To avoid “AI theater,” we stuck to a few practical metrics and pulled baseline numbers from the helpdesk and internal logs. No vibes. Just receipts.

First response time (FRT) by ticket category
Time-to-resolution for common requests
Reopen rate (tickets reopened after being “solved”)
Escalation rate (how often issues had to be handed to engineering)
Top repeated topics (to target quick wins)

This baseline shaped the automation plan. It also helped later when someone inevitably asked, “Cool demo… but did it actually help?”

Solution Overview: A Multi-Agent Support Workflow (Not One Chatbot)

Instead of one “do everything” bot, we built a small team of AI Agents, each with a narrow job and clear rules. Think of it like assigning roles in a support squad instead of hiring one intern and hoping they can do accounting, IT, and customer success before lunch.

We implemented custom AI agents to automate triage and resolution for recurring support requests. If you want the conceptual overview of what agents are and how they work, start here: AI agents.

The agent roles we deployed

Classifier Agent: labels tickets (billing, onboarding, bug, account access, etc.) and detects urgency
Policy Agent: checks requests against refund rules, account policies, and compliance constraints
Answer Drafting Agent: creates a structured draft response with citations to internal docs
Routing Agent: decides “auto-send,” “send with human review,” or “escalate to specialist”
Summarizer Agent: creates a short internal summary for humans when escalation is needed

Why this pattern worked in production

This setup is safer and easier to maintain than one giant prompt for a few reasons.

Each agent has limited scope (fewer hallucinations)
You can add rules like “never change billing data” or “never promise timelines” per agent
Failures are easier to trace: you can see whether classification, policy checks, or drafting caused the issue

Implementation Details: Data, Integrations, and Secure Automation

We hooked the pipeline into the client’s helpdesk (tickets + macros), knowledge base, and internal user database. The system pulled only the minimum data it needed, then scrubbed sensitive fields before any model call. That part matters a lot in real support, because tickets can include passwords, payment details, or personal info people absolutely should not be sending (but do anyway).

The core flow (high-level)

Webhook receives new ticket from helpdesk
Pre-processor removes sensitive data and normalizes the ticket text
Classifier Agent assigns category + confidence score
Policy Agent checks constraints (refund windows, account rules, compliance notes)
Answer Drafting Agent generates a reply + references
Routing Agent chooses one of three paths:
- Auto-send
- Human review queue
- Escalation queue
All decisions and model outputs are logged for audit and improvement

Security and privacy decisions (battle-tested)

PII minimization: only send required fields to the model
Role-based access: only approved services can fetch account context
Prompt injection defense: treat customer text as untrusted input, isolate it, and enforce hard constraints
Audit logs: store agent decisions, confidence, and the exact prompt template version
Rate limits and retries: protect upstream helpdesk APIs and avoid duplicate replies

A simple routing rule example

// Pseudocode: never auto-send low-confidence or policy-sensitive answers
if (classification.confidence < 0.85) return "HUMAN_REVIEW";
if (policy.flags.includes("REFUND_REQUEST")) return "HUMAN_REVIEW";
if (ticket.tags.includes("VIP")) return "HUMAN_REVIEW";
return "AUTO_SEND";

This kind of rule-based guardrail is what makes automation feel trustworthy. Without it, you get that sweaty feeling like you just gave the keys to the car to a teen who “totally knows how to drive.”

Quality Control: Prompts, Evaluations, and “Safe to Send” Gates

The fastest way to wreck a support automation project is shipping without quality checks. We treated every outgoing reply like a real production release. It needed consistency. It needed to follow policy. It needed a way to measure when it went wrong.

To standardize outputs and measure quality, we used a library of prompt templates and evaluation checks before rolling automation across all categories: prompt templates and evaluation tools.

The “safe response” checklist

Every draft answer had to pass these gates:

Tone check: friendly, direct, no blame
Policy check: never offer refunds outside allowed windows
Accuracy check: only claim what the system can verify
Actionability check: includes clear next steps
No sensitive echo: don’t repeat secrets the user typed (like passwords)

How we reduced hallucinations

We kept things grounded by doing a few simple (but powerful) moves:

Using short, structured prompts with clear constraints
Adding “allowed sources” (knowledge base + approved macros)
Forcing the agent to cite which doc section it used
Routing “no-source” answers to human review

Human-in-the-loop where it mattered

Even with strong gates, some categories should stay human-led. Not because the tech can’t help, but because the risk and nuance are higher.

Complex billing disputes
Legal/compliance topics
High-severity bug reports
VIP accounts

This is how you keep automation high without making customers feel like they’re debating a robot that can’t bend.

Results: 80% Automation Without Tanking Customer Experience

After rolling out in phases (starting with the most repetitive categories), the quick wins showed up fast. Password resets, basic onboarding questions, and “where do I find X” tickets were perfect for automation. They were predictable, and the documentation was clear.

Here’s what changed once the AI Agents workflow stabilized:

Metric	Before	After	What changed
Tickets handled end-to-end	0%	80%	Auto-triage + auto-reply for repetitive categories
First response time	Slow during peak	Much faster	Drafting + routing removed backlog delays
Reopen rate	Higher	Lower	More consistent answers + better next steps
Agent workload	Constant firefighting	Focused on hard cases	Humans handled the tricky 20%

What made the 80% possible

We automated only tickets with strong confidence and safe policy boundaries
We added review queues so humans could approve answers in sensitive categories
We improved the prompts and evaluation rules weekly using real ticket outcomes

Common mistakes we avoided

Automating everything on day one
Letting the model “guess” when data was missing
Shipping without logs, versioning, and rollback options

How You Can Replicate This Pattern (Safely) in Your Own Support Stack

If you want to build something like this, start small and treat it like a real system, not a flashy demo. Pick 1, 2 high-volume categories, automate triage + drafting, and add human approval while you tune quality. That’s the difference between “this is neat” and “this is actually running our support queue.”

A practical rollout plan

Choose your first categories (password resets, FAQ-style onboarding)
Write a clear policy file (refund rules, promises you cannot make, escalation triggers)
Build a classifier + routing gate (confidence thresholds matter)
Add a drafting agent that uses only approved docs
Log everything and review failures weekly
Expand category by category

Tools and architecture tips (beginner-friendly)

Use a webhook-based backend (e.g., FastAPI) for ticket events
Keep a small database table for prompt versions and evaluation results
Implement strict “auto-send” rules; don’t rely on vibes

If you want to learn the underlying method behind agent behavior, start with the prompt engineering foundations that power reliable agent responses in customer support: prompt engineering foundations.

In production, AI Agents work best when they’re narrow, measurable, and guarded by clear rules. That’s how you get to 80% automation while still protecting customers, brand voice, and security.

10 Best AI Engineering GitHub Repos to Build Real Systems

Robort Gabriel — Wed, 07 Jan 2026 12:13:23 +0000

You pick up practical AI engineering faster by digging into real code, real notebooks, and real systems. I’ve learned more by breaking stuff and fixing it than by watching one more lecture. These repos are free, well-structured, and focused on what actually works in practice, helping you move from theory to shipped features.

Each pick includes hands-on materials and clear guidance. You’ll find lessons, notebooks, examples, and end-to-end projects that run without yak-shaving. Let’s walk through the 10 repos and how they help you build useful AI systems.

1. Hands-On Large Language Models

It’s the full code from the book, with notebooks covering LLM basics, training, and fine-tuning. If you like a guided, notebook-first path from foundations to customization, this feels like a friendly trail map. Link: https://github.com/HandsOnLLM/Hands-On-Large-Language-Models

2. AI Agents for Beginners (Microsoft)

A free, structured 11-lesson course to start AI agents the right way. Think of it as turn-by-turn directions for agents, minus the detours and dead ends. Link: https://github.com/microsoft/ai-agents-for-beginners

3. GenAI Agents

Clear tutorials and implementations of generative AI agent techniques, from basic builds to advanced strategies. You’ll see how different agent strategies are wired up, which makes design choices feel obvious. Link: https://github.com/NirDiamant/GenAI_Agents

4. Made With ML

One of the best resources for building production-grade ML systems end to end. My pick when you care about real-world systems and operational quality, not just pretty notebooks. Link: https://github.com/madewithml/basics

5. Prompt Engineering Guide

A massive collection of guides, papers, notebooks, and resources on prompt engineering. Keep it handy when you want proven patterns and quick references in one place. Link: https://github.com/dair-ai/Prompt-Engineering-Guide

6. Hands-On AI Engineering

Curated examples of AI-powered applications and agentic systems using LLMs that actually run. It shows how the pieces snap together in working examples, which saves a lot of guesswork. Link: https://github.com/Sumanth077/Hands-On-AI-Engineering

7. Awesome Generative AI Guide

A one-stop repo for GenAI research updates, notebooks, interview prep, and more. Great for staying current while practicing with solid reference materials you can trust. Link: https://github.com/aishwaryanr/awesome-generative-ai-guide

8. Designing Machine Learning Systems (Resources)

Summaries and references for one of the most important ML systems books out there. It strengthens your systems thinking, which quietly prevents half the headaches before they begin. Link: https://github.com/chiphuyen/dmls-book

9. Machine Learning for Beginners (Microsoft)

A beginner-friendly ML curriculum with practical examples and exercises you can actually finish. A solid starting point if you’re new to ML and want quick wins. Link: https://github.com/microsoft/ML-For-Beginners

10. LLM Course

A hands-on, end-to-end course on building, evaluating, and deploying LLM applications. Ideal when you want a clear path from spark of an idea to deployment. Link: https://github.com/mlabonne/llm-course

For even more hands-on repos, explore this curated list of open-source AI projects.

These resources focus on what matters: practical skills, working examples, and clear steps. Pick one that fits your level and goal, set a tiny deadline, and move through the materials with intent.

You can continue by exploring AI source code repositories and examples to build on these projects and deepen your practice.

Building Resilient AI Agent Workflows That Handle Real-World Data Messiness

Robort Gabriel — Fri, 02 Jan 2026 22:30:00 +0000

In the excitement around AI agents — autonomous systems that can plan, reason, and execute multi-step tasks — it's easy to forget one brutal truth: real-world data is messy. Invoices come as scanned PDFs with coffee stains, customer records have dates in five different formats, APIs return 429s or silently change schemas, and your "clean" database has duplicate entries from a merger three years ago.

Prototypes built on tidy datasets work beautifully in demos. In production? They hallucinate, loop infinitely, corrupt data, or simply crash when faced with the chaos of actual business information.

As we enter 2026, the difference between toy agents and production-grade ones isn't smarter models — it's resilience engineering. Here's how to build AI agent workflows that don't just survive messy data, but thrive despite it.

1. Accept Reality: Data Will Always Be Dirty

Garbage In, Garbage Out (GIGO) didn't go away with foundation models. Even the most capable LLMs stumble when:

Parsing inconsistent formats (e.g., "01/02/2026" vs. "2 Jan 26" vs. "2026-01-02")
Handling missing values or outliers
Dealing with schema drift in APIs
Encountering poisoned or adversarial inputs

Real-world examples abound: agents silently creating duplicate CRM records because a tool call partially failed, or hallucinating financial figures from poorly extracted text in PDFs.

The first step in resilience? Stop pretending your data will be clean. Design assuming messiness is the default.

2. Core Principles for Resilient Agent Workflows

Principle 1: Validate Early, Validate Often

Never trust input — even from your own systems.

Schema validation on ingress: Use Pydantic models or JSON Schema to enforce structure before any agent touches the data.
Pre-processing agents: Dedicate lightweight agents/tools just for normalization (date parsing, entity extraction, deduplication).
Post-tool validation: After every external call or parsing step, validate the output matches expectations.

Example: In a customer onboarding workflow, validate extracted email/phone before creating records. If invalid, route to human review instead of proceeding.

Principle 2: Embrace Retries, Fallbacks, and Circuit Breakers

Networks flake, APIs rate-limit, models hallucinate.

Exponential backoff retries for transient failures
Fallback models/tools: If primary parser fails, try a simpler regex-based one
Circuit breakers: Temporarily disable flaky tools to prevent cascading failures

Frameworks like LangGraph (from LangChain) or Temporal make stateful retries trivial — your agent can pause, wait, and resume exactly where it left off.

Principle 3: Make Reasoning Observable and Controllable

Black-box agents are impossible to debug when things go wrong.

Log every reasoning step (chain-of-thought)
Use structured outputs (JSON mode, function calling) instead of free text
Add guardrails: Maximum steps, cost limits, approval gates for high-risk actions

Tools like LangSmith or Helicone give you traces showing exactly where an agent went off the rails because of bad data.

Principle 4: Use Orchestration That Survives Failures

Simple sequential chains die on the first error. Production needs durable execution.

Stateful orchestrators: Temporal, LangGraph, or DBOS ensure workflows resume after crashes
Saga pattern for multi-step transactions: If creating a user succeeds but sending welcome email fails, automatically compensate (delete the user)
Human-in-the-loop escalation: When confidence is low or data is too messy, hand off to a human

This prevents the dreaded "silent data corruption" where half the workflow succeeds and leaves your systems inconsistent.

3. Practical Patterns for Handling Messy Data

Challenge	Pattern	Tools/Techniques	Why It Works
Inconsistent formats	Normalization agent	Unstructured.io, LlamaParse, custom parsers	Converts chaos into structured JSON early
Missing/ambiguous data	Confidence scoring + escalation	LLM self-assessment prompts	Knows when it doesn't know
Schema changes in APIs	Versioned tool wrappers + validation	Pydantic for inputs/outputs	Fails fast and predictably
Hallucinations on extraction	Multi-pass verification	Compare outputs from 2+ models/methods	Consensus beats single-source truth
Partial tool failures	Compensating actions (Sagas)	Temporal, custom rollback logic	Maintains data integrity

4. Real-World Example: Invoice Processing Agent Crew

Imagine an accounts payable workflow:

Ingestion Agent: Downloads email attachments (PDFs, images, Excel)
Extraction Agent: Uses multimodal model to extract fields
Validation Agent: Checks totals match, dates are valid, vendor exists in DB
Enrichment Agent: Looks up vendor terms, tax rules
Approval/Booking Agent: Routes for human approval if confidence < 90%, otherwise books in ERP

With resilience baked in:

If extraction fails → retry with different model → escalate to human
If ERP API down → pause workflow, notify, resume later
All steps logged with input/output traces

This crew processes 95%+ of invoices autonomously, even when they're scanned upside-down or in foreign languages.

5. The Future: Self-Healing Agents

We're already seeing the next wave:

Agents that monitor their own error rates and trigger retraining
Synthetic data pipelines to simulate messy scenarios during testing
Adaptive workflows that reroute around chronically bad data sources

But none of this works without the fundamentals above.

Conclusion: Resilience > Intelligence

In 2026, the winning AI agent systems won't be the ones with the flashiest reasoning chains. They'll be the boring, robust ones that just keep working when data is incomplete, APIs are flaky, and requirements change.

Build for failure. Validate ruthlessly. Orchestrate durably. Observe everything.

Your agents will thank you — and so will your ops team at 3 AM when nothing is on fire.

What’s the messiest data your agents have had to deal with? Share in the comments — let’s build more resilient systems together.

32 Low-Code Platforms I Tested: Build Apps Fast, Automate Workflows

Robort Gabriel — Tue, 02 Dec 2025 09:48:23 +0000

Low-Code Platforms put app development, workflow automation, and process orchestration within reach for more of us. I’ve watched teams go from “spreadsheet chaos” to working apps before lunch, and yes, it’s as satisfying as it sounds.

This curated set spans AI-powered low-code, no-code builders, open-source options, and database-integrated suites. Across these tools, you can spin up custom business apps, automate workflows, modernize operations, and plug data into core systems without the usual headaches.

Some platforms double down on speed, scalability, governance, and security. Others shine for internal tools, CRM-driven apps, portals, and mobile/web experiences.

Whether you want a unified metadata platform, an enterprise process orchestrator, or an open-source internal tool builder, you’ll find options that streamline processes, boost productivity, and help non-developers ship professional-grade solutions.

Enterprise Low-Code Platforms for Apps and Processes

These Low-Code Platforms combine AI, visual development, and enterprise-grade governance, so teams can build scalable mobile and web apps without feeling like they’re wiring a spaceship. You get smoother processes, better customer experiences, and unified data, CRM, and automation under one roof.

With strong integrations, they connect to core systems and support mission-critical journeys. Collaboration and extensibility spark innovation across the SDLC, while unified metadata models and process orchestration keep builds consistent and secure. From empowering non-developers to crafting custom agents and decisioning, these platforms prioritize speed, scalability, and real revenue outcomes.

Microsoft Power Apps

A low-code AI app builder for creating custom business apps that streamline processes, boost productivity, and integrate with Microsoft ecosystems, empowering non-developers to build professional-grade solutions. Microsoft Power Apps

OutSystems

An AI-powered low-code platform for building enterprise apps and custom agents with full SDLC governance, focusing on speed, scalability, and integration with core systems for revenue-driving solutions. OutSystems

Mendix

A fast, collaborative low-code platform for developing scalable mobile and web apps, with strong AI integration and extensibility, ideal for businesses unlocking innovation across the SDLC. Mendix

Appian

An AI-powered process orchestration platform that automates workflows, reduces costs, and enhances customer experiences, serving as a unified solution for enterprise process management. Appian

Pega

An AI-powered enterprise platform for workflow automation and decisioning, enabling customer-centric apps and transformations with low-code tools for complex, mission-critical journeys. Pega

Salesforce Platform

A unified metadata platform integrating data, AI, CRM, and low-code tools for building secure, customizable apps that empower teams in sales, service, and beyond, with rapid development capabilities. Salesforce Platform

Workflow Automation and Operations Suites

These platforms focus on AI, automation, and process modernization, which is a fancy way of saying they help you stop chasing approvals in your inbox. They unify people, systems, and operations across front-, mid-, and back-office work, with strong governance and security baked in.

With process orchestration, approvals, notifications, and a pile of integrations, teams can cut costs and upgrade customer experiences. Generative AI speeds up building, and natural-language features help you ship apps without wrestling with syntax. Whether you need end-to-end automation, portals, or CRM-aligned workflows, these tools give you a governed, scalable base for enterprise operations.

ServiceNow App Engine

A workflow app builder for modernizing processes with AI and automation, unifying people, systems, and operations across front- and back-office tasks for efficient, scalable enterprise solutions. ServiceNow App Engine

Nintex

A process management suite with low-code and AI for automating workflows, custom apps, and integrations, ensuring governance, security, and alignment with business goals. Nintex

Kissflow

An AI-powered low-code/no-code platform for custom enterprise apps and workflow automation, simplifying approvals, notifications, and integrations for business efficiency. Kissflow

NewgenONE

A low-code platform for end-to-end automation across process, content, and AI, unifying front-, mid-, and back-office for rapid, intelligent operations at scale. NewgenONE

SAP Build

A low-code/pro-code suite with generative AI for app development, process automation, and portals, integrating Joule AI for efficient, context-aware building across HR, finance, and more. SAP Build

Creatio

A no-code CRM and workflow platform with native AI agents for building and deploying apps via natural language, focusing on sales, operations, and customer engagement. Creatio

Internal Tools and Engineering Builders

Engineering and business teams use these platforms to spin up internal tools, dashboards, portals, and secure full-stack apps without reinventing the wheel. They connect databases, APIs, and LLMs, and ship with schema-aware UIs, built-in auth, permissions, audit logs, and React components.

With visual builders, open standards, and portability, teams deploy fast while keeping enterprise-grade control. Backend services, UI builders, and AI automation give flexibility for scalable apps without external dependencies. It’s a practical path to modernization and extensibility across use cases.

Retool

An AI-enhanced internal tools builder connecting databases, APIs, and LLMs to create secure, schema-aware UIs and automations, ideal for engineering and business teams deploying quickly. Retool

Superblocks

An AI internal app platform generating full-stack apps with built-in auth, permissions, and audit logs, uniting engineers and IT for secure, portable enterprise solutions. Superblocks

UI Bakery

A low-code builder for admin panels, dashboards, and portals with AI agents, React components, and API integrations, enabling fast, customizable internal tools. UI Bakery

Backendless

A visual app development platform with UI builder, backend services, and AI automation (FlowRunner), offering flexibility for scalable apps without third-party dependencies. Backendless

WaveMaker

A low-code tool for building, modernizing, and scaling enterprise apps with open standards, intuitive visuals, and per-developer licensing for speed without lock-in. WaveMaker

GeneXus

An AI-powered enterprise low-code platform for accelerating product development with reusable web components, scalability, and multi-device app building without vendor lock-in. GeneXus

Open-Source and Visual Builders for Teams

These choices include open-source and visual builders that offer full code control, AI actions, and simple drag-and-drop. You can connect to databases, LLMs, and third-party services, then add JS/SQL where it makes sense.

With self-hosted or community editions, teams can build internal and external solutions at low cost. Visual design and governed frameworks keep projects extensible and secure. It’s a great way to assemble custom apps, workflows, and automations while staying in control.

Appsmith

An open-source low-code platform offering full code control and AI actions for building apps with JS logic, connecting to LLMs and databases, perfect for custom internal tools and workflows. Appsmith

Tooljet

An open-source low-code platform with PostgreSQL database, UI editor, and integrations for building internal apps, workflows, and data management in minutes via Docker. Tooljet

Budibase

An open-source low-code platform for internal tools and automations, connecting to any data source with optional coding, ideal for quick shipping of workflows and apps. Budibase

NocoBase

An AI-driven, open-source no-code/low-code platform for self-hosted data management and workflows, enabling quick, extensible private solutions for HR, operations, and more. NocoBase

Lowcoder

A rapid app builder for AI and business apps with free community edition, offering JS/SQL control and public cloud trials for internal/external solutions at low cost. Lowcoder

Betty Blocks

An AI-based low-code platform for secure, governed custom apps, allowing rapid delivery for business users with visual design and extensibility. Betty Blocks

Database-Integrated and No-Code App Builders

These platforms emphasize database integration, point-and-click development, and visual builders for secure web and mobile apps at scale. You can support unlimited users, lean on AWS/SQL, and build complex business apps fast.

Automate processes, start from templates, and plug into third-party or native ecosystems. Drag-and-drop simplicity, no-cost tiers, and flexible deployment help teams ship and share workgroup apps, streamline operations, and modernize without getting boxed in by vendors.

Oracle APEX

A no-cost, database-integrated low-code platform for building secure web and mobile apps at scale, leveraging Oracle's ecosystem for rapid development and deployment anywhere. Oracle APEX

Caspio

A point-and-click low-code platform for online database apps, offering unlimited users, AWS/SQL scalability, and quick builds for complex business applications. Caspio

Quixy

A no-code/AI platform for enterprise app development and process automation, enabling effortless custom solutions, insights, and decisions with drag-and-drop simplicity. Quixy

Zoho Creator

A low-code platform with AI assistance for building custom web and mobile apps, automating workflows, and integrating with Zoho or third-party systems to streamline business operations. Zoho Creator

Quickbase

A customizable no-code platform for building and sharing online workgroup apps, with templates and integrations to automate processes without additional costs for licensed users. Quickbase

AwareIM

A comprehensive low-code platform for 10x faster enterprise apps, using visual drag-and-drop for data models, rules, queries, and workflows in plain English. AwareIM

Commerce, Integration, and Automation Extensions

These solutions power e-commerce backbones, custom tools, and visual integrations. They help you innovate fast in apps and processes with extensible, business-focused tooling and secure, e-commerce-ready performance.

Visual builders and AI make it easy to create tools, workflows, and integrations without heavy coding. If you want to connect apps and automate quickly, these choices pair nicely with broader Low-Code and no-code stacks.

Rierino

A smart low-code backbone for e-commerce and digital transformation, enabling quick innovation in apps and processes with extensible, business-focused tools. Rierino

Blaze.tech

A no-code builder for custom tools, web apps, and workflows with AI integrations (e.g., payments, scheduling), focusing on secure, e-commerce-ready business performance. Blaze.tech

Zapier

Zapier helps you automate workflows between apps with a visual builder, ideal for creating integrations without coding. Explore the Zapier automation platform to get started.

Code2

Code2 lets you build and launch web apps rapidly using a visual, low-code approach. Learn more on the Code2 low-code app builder page.

Zapt AI

Zapt AI provides a no-code builder to create custom tools and workflows quickly. Check out the Zapt AI no-code builder for details.

Antigravity vs Claude Code: Ultimate Agentic Dev Showdown

Robort Gabriel — Sun, 30 Nov 2025 19:02:14 +0000

Antigravity vs Claude Code at a glance

Here’s how I explain it when a teammate asks which one to try first. Google’s antigravity feels like a teammate who loves to own the whole task and report back with proof.

It plans, browses, executes, and iterates. Google explicitly frames Antigravity as an IDE-like, multi-agent environment that can plan, browse, execute, and iterate; see Google’s announcement, “Today we’re releasing Google Antigravity, our new agentic development platform,” which details how Gemini 3 powers its tool use and reasoning: Today we're releasing Google Antigravity, our new agentic development platform.

Antigravity is powered by Google’s latest Gemini model, which explains its planning and multi-agent strengths, see how Gemini works here: Gemini AI Tool.

In contrast, claude code leans into a classic “chat-with-your-code” flow that prioritizes fast, careful code suggestions and clear explanations.

Attribute	Antigravity	Claude Code
Primary mode	Agentic development platform (IDE-like)	Conversational coding assistant (editor/web)
Autonomy	High; plans, executes, tests, and revises	Moderate; suggestive and iterative by default
Multi-agent	Yes; parallel agents per task	Typically single-agent interaction
Browser control	Built-in, human-like browsing and testing	Limited/indirect; depends on plugins/tools
Artifacts	Docs, screen captures, structured outputs	Code diffs, explanations, long-context summaries
Human review	Comment on artifacts, inbox triage	Chat review, inline suggestions in IDE
Ideal uses	End-to-end feature delivery, UI tests, research	Refactors, bug fixes, explanations, test writing

I’ve seen social demos where Antigravity nails an app’s look and flow on the first pass. Fun to watch, but keep in mind that prompts, repo setup, and environment quirks matter.

In quick comparisons, one user found Antigravity’s design closer to the project’s intent than a competing editor; that could be stronger repo grounding, broader tool access, or a lucky prompt.

Meanwhile, claude code keeps winning fans for readable outputs, helpful explanations, and careful changes.

Real differences will hinge on your repo size, runtime limits, and how much autonomy you want versus a tight human-in-the-loop rhythm.

How Antigravity works in practice (agentic browser + multi‑agent flow)

Antigravity resembles an IDE with a file tree, terminal access, and a canvas where agents plan and run tasks in parallel.

Beyond code generation, it can launch a real Chrome session, run live tests, capture screenshots or short recordings, and produce reviewable artifacts like docs you can comment on.

Google describes this as part of Gemini 3’s “advanced agentic coding capabilities,” alongside the debut of Antigravity itself: Gemini 3 is introducing advanced agentic coding capabilities, plus Google Antigravity.

For a sense of how agentic browser control works in practice, here’s a platform that lets AI operate a real browser end‑to‑end: Browserbase AI Tool. I’ve even watched it fix a timezone bug I created, then politely summarize the fix like a teammate on their third espresso.

In a typical scenario (like a flight-tracking mini‑app), Antigravity will propose a plan, set up services, call external APIs, and then auto‑test the result in the browser.

Because it returns screenshots and creates artifacts, you can annotate issues (“fix the date format,” “handle errors on 4xx”) and let the agent iterate.

Some demos even show design explorations (e.g., generating multiple UI directions) before committing to a final look. This workflow blurs boundaries between planning, coding, browsing, and QA.

It’s powerful, but it also makes governance important, decide what the agent may run, what domains it can browse, and when a human must approve changes, especially in production or security‑sensitive code.

Where Claude Code shines (reliability, clarity, and long‑context reasoning)

claude code acts like a calm, dependable coding buddy in your editor or web UI. It’s great at explaining errors, proposing small, safe diffs, and keeping a consistent style across large files thanks to strong long‑context reasoning.

Many teams use Claude for refactors, unit test generation, docstrings, and quick design spikes because the model is careful and articulate by default.

If your workflow favors readable patches, incremental iteration, and human gatekeeping over full autonomy, Claude is a great fit. To evaluate Claude’s broader coding capabilities and ecosystem, review: Anthropic Claude.

From there, choose your style: steady back‑and‑forth with precise prompts, or occasional instructions that let an agent run multi‑step plans.

Trade‑offs to consider with Claude Code

Claude’s clarity and safety mean it’s less likely to take sweeping, system‑level actions without explicit approval.

That’s ideal for regulated environments or whenever you want a tight loop around diffs, tests, and reviews.

On the other hand, if you need an agent to open the browser, click through multi‑page flows, and gather live data while building, you’ll likely need external tooling or plugins to match Antigravity’s integrated behavior.

Consider context limits, repo size, your CI rules, and how often you want the model to touch the terminal or OS. The right fit depends on your tolerance for autonomy and your guardrails.

How to choose: a quick decision framework

Start with the level of autonomy you want. If you need end‑to‑end execution, planning, browsing, coding, and testing, inside one environment, antigravity is purpose‑built for that.

If you prefer stepwise collaboration and high‑signal explanations, claude code fits well. Next, evaluate your repo size and stack complexity; agentic browsers help when flows span multiple services and UI states.

Finally, decide on governance: who approves commands, what tools are accessible, and how to log actions.

Use the quick prompt below in both tools to standardize your comparison, then score outcomes on design quality, code correctness, test coverage, and iteration speed.

Autonomy: end‑to‑end agent vs. suggest‑and‑review assistant
Environment: IDE‑like platform with browser control vs. editor‑centric chat
Governance: command approvals, browsing domains, data access, logs
Outputs: artifacts with comments vs. diffs and explanations
Team fit: rapid prototyping vs. conservative refactors in existing codebases

You are an expert full‑stack pair‑programmer. Build a minimal “Flight Status” web app:
- Input: airline + flight number; Output: live status, origin/destination, scheduled/actual times
- Stack: your choice, but justify it in a short design note
- Include basic tests, error states, and accessible UI
- Show me: running app, test results, and a short README with setup steps
- Then propose 2 design variants and implement the one I select

Mcp servers: Complete Setup for AI Agents (Step-by-Step)

Robort Gabriel — Sat, 15 Nov 2025 10:42:19 +0000

When you wire up agents and tools for AI apps, there’s a small set of Mcp servers that act like the secret crew behind the scenes. Get these right and your development feels reliable, repeatable, and far less likely to produce nonsense from the model.

This short guide lists the essential MCP servers to run, what each one fixes, and quick tips for getting them to play nicely together. Think of it as a checklist while you set up your local or cloud dev environment.

Overview: why these MCP servers matter for agents

What this section covers

A few MCP servers provide the plumbing that turns an LLM from a wild guesser into a helpful, repeatable assistant. They give agents live docs, project memory, browser control, and database access.

Without them, agents tend to hallucinate, lose project context, or fail at real-world tasks like clicking a UI or writing to a DB.

Key benefits

Up-to-date docs so the model can verify library APIs before using them.
Project and global memory so agents remember past choices and requirements.
Browser control to reproduce human interactions and debug UI flows.
Database access for persistent state and transactional reads/writes.

Use this overview as the checklist to compare against your current environment before diving into specific MCP servers.

Context7 MCP, live doc search to reduce hallucinations

What Context7 does

The Context7 MCP server lets agents search live, versioned docs and code comments so they reference real API signatures and usage examples.

When agents can pull the exact docs, they stop inventing functions or guessing parameters. That alone cuts hallucinations by a lot.

How to use it


mcpctl add context7 --url http://localhost:8000

For guidance on crafting system prompts that keep your agents from hallucinating when using a live context server, see our system prompt engineering guide.

Also review the open-source implementation at Context7 MCP Server -- Up-to-date code documentation for LLMs and AI to understand how it fetches and indexes docs for fast agent queries.

Archon MCP, project and global memory management

Why Archon matters

The Archon MCP server is the memory bank for your agents. Instead of feeding an agent only the current prompt, Archon stores project notes, decisions, issue history, and task state so agents keep continuity across sessions.

For bigger projects or multi-agent setups, this is the difference between helpful behavior and the agent repeatedly asking the same question.

How to integrate Archon

Run Archon locally or in a container and mount it as your agent's memory provider. Give agents scoped access: project-level context for repo facts and global context for company policies or shared libs. That keeps sensitive data separated while letting agents reason with the right facts.

For a practical implementation reference and the early OSS release, see the Beta release of Archon OS - the knowledge and task management backbone for AI coding assistants. Use Archon together with a Context MCP so memory and live docs stay in sync.

Playwright MCP, let agents control browsers like humans

What Playwright MCP enables

A Playwright MCP server gives agents human-like browser access. They can open pages, inspect DOM nodes, read console logs, click buttons, fill forms, and take screenshots.

That turns agents into real testers and automation helpers, able to reproduce UI flows instead of guessing HTML.

Integration tips

Expose a secure, authenticated Playwright MCP endpoint to your agent runtime.
Provide page-level abstractions so the agent can click, type, and waitForSelector without writing low-level code each time.
Log all interactions and console output to your project memory so agents can review failures later.

Use code-style patterns and short helper prompts so your agent issues predictable browser commands.

For example, instruct the agent to prefer waitForSelector before clicking to avoid flakiness.

Database MCP, Supabase or local SQL for persistent context

Why a Database MCP is essential

A Database MCP connects agents to structured, persistent storage. Whether you choose Supabase, a local SQLite/Postgres, or another SQL store, this server lets agents read and write project state, user data, feature flags, and logs.

Persistence keeps agents consistent across restarts and lets them make real changes (like updating a user record or recording a deployment note).

Best practices

Use parameterized queries and role-based access to limit agent permissions.
Record agent actions as auditable events so you can roll back or trace changes.
Normalize memory usage: store short-term conversational state separately from long-lived domain records.

If you want step‑by‑step guidance on wiring an agent to a context database or Supabase-backed memory, read our guide on how to build a custom AI chatbot.

Conclusion: get these Mcp servers running before full-scale agent work

Running the four MCP servers, Context7, Archon, Playwright, and a Database MCP, gives your agents the core tools they need to act like dependable developers. Context-driven doc search stops hallucinations, Archon provides continuity, Playwright lets agents interact with UIs, and a database gives durable memory.

Start with these MCP servers in a dev environment, keep interactions logged, and tweak system prompts so agents behave predictably.

If you want a quick checklist: install Context7, deploy Archon, enable Playwright, and connect your database. With those pieces in place, your agents will be far more reliable and useful during real development work.

Save this checklist and return to it each time you provision new agent-powered projects.

System Design Interview Playbook: Clear Steps to Shine

Robort Gabriel — Sun, 21 Sep 2025 09:06:28 +0000

System design sits at the heart of the technical Interview. It can look huge at first, but it doesn’t need to be. With a simple, repeatable game plan, you can show clear thinking, good engineering judgment, and solid communication. This guide turns a fuzzy prompt like “design Instagram” into a calm, easy chat, without breaking a sweat or drawing a data center with 17 mystery boxes.

System design also matters for career growth. Senior roles expect you to reason about scale, reliability, and trade‑offs, not just write code. If you want to understand how system design fits into the broader set of in-demand abilities for senior engineers, see our guide to high-income tech skills.

You’re not building the entire company in one hour. Pick a slice, design it well, and explain the trade‑offs clearly.

What Interviewers Really Evaluate

Interviewers want more than a pretty diagram. They’re looking at how you:

Clarify scope and remove ambiguity
Separate functional and non-functional requirements
Choose sensible APIs and data models
Communicate trade‑offs (consistency vs availability, latency vs cost, build vs buy)
Scale the design step by step, not all at once
Collaborate: ask questions, validate assumptions, and listen to signals

Keep the conversation two-way. Ask what matters most and go deeper there.

A 5-Step Framework You Can Reuse

Use this simple approach in any system design Interview.

1) Clarify the Scope

Start by shrinking the problem. Suppose you’re asked to design a social media app like Instagram. Ask:

Which features should we focus on, uploading content, viewing the feed, or messaging?
What’s the target region and expected user scale?
Are we optimizing for mobile, web, or both?
Is real-time interaction a must-have, or can updates be slightly delayed?

This avoids overbuilding and guides your choices later.

2) Gather Requirements

List requirements and label them clearly.

Functional requirements (what it should do):
- Users can upload images and short videos
- Users can view a home feed of posts
- Users can like and comment
- Users can follow other accounts
Non-functional requirements (how it should behave):
- High availability and low latency for reads
- Reasonable write performance under spikes (e.g., viral posts)
- Durability of media and metadata
- Horizontal scalability (many users, many posts)
- Security, privacy, and basic compliance

As you weigh trade-offs, remember the CAP theorem, which says a distributed system can’t deliver all three of consistency, availability, and partition tolerance at once. In practice, you’ll often pick availability and partition tolerance for user-facing reads, with eventual consistency for non-critical counters and feeds.

3) Sketch APIs and a Data Model

Don’t aim for perfect. Keep it simple and show you can translate requirements into an interface.

Example APIs for an “upload + view feed” slice:

POST /posts (body includes media URL, caption, userId)
GET /feed?userId=&cursor=&limit=
POST /likes (postId, userId)
GET /posts/{id}

Rough data model:

User(id, handle, name, createdAt)
Post(id, userId, caption, mediaUrl, createdAt)
Follow(followerId, followeeId, createdAt)
Like(postId, userId, createdAt)

Note a few access patterns:

Feed reads dominate: GET /feed is a hot path
Post writes include metadata to a database and media to blob storage
Likes/comments are small writes but high volume on popular posts

Call out indexes and partitions if needed: e.g., index Follow by followerId for fast feed fan-out, and partition Post by userId or time.

4) Draw a Baseline Architecture

Describe a simple, clean baseline before you scale it up:

Client (mobile/web)
Load Balancer
App tier: separate paths for reads vs writes (reads typically outnumber writes)
Metadata database (start with a relational DB if data is highly relational)
Blob storage for images/videos
CDN in front of media for global performance

Text version of the flow:

Client → Load Balancer → App (Write) → DB (metadata) + Blob Storage (media)
Client → Load Balancer → App (Read) → DB + Cache + CDN (for media)

This baseline maps directly to functional requirements and gives you a platform to layer more capabilities.

5) Layer in Scale, Reliability, and Performance

Add components gradually and explain why:

Caching for hot reads (e.g., Redis) to reduce DB load
Background workers and queues for fan-out, thumbnail generation, and notifications
Search/indexing using a dedicated service (e.g., OpenSearch/Elasticsearch)
Rate limiting and auth for safety
Monitoring, logging, and tracing for visibility
Feature flags and gradual rollouts for safety during changes

Be explicit about each new piece: what problem it solves, how it fits in, and the trade-offs it brings.

From Baseline to Production: What to Add and Why

Use this as a checklist during the interview to justify each layer you propose.

Layer	Component	Why it matters
Performance	CDN + Cache	Low-latency reads and offload from origin servers
Durability	Blob Storage	Durable, cheap storage for images and videos
Reliability	Multi-AZ/Region DB	High availability and disaster recovery
Scalability	Sharding/Partitioning	Handle growth in posts, users, and traffic
Asynchronicity	Queue + Workers	Smooth spikes, process jobs out-of-band
Observability	Metrics + Logs + Traces	Detect issues and improve performance
Safety	Rate Limits + WAF	Protect against abuse and overload

Keep the conversation practical. Tie each component back to a requirement.

Handling Data and Consistency Like a Pro (But Simply)

You don’t need to be academic, but you should show you understand consistency trade-offs.

Strong vs eventual consistency: Likes count may be eventually consistent. Payment ledger must be strongly consistent.
Read-heavy endpoints (feeds, profiles) can accept slightly stale data to keep latency low.
Write paths should be idempotent: retries shouldn’t duplicate a like or a post.
Use durable storage for media and consider pre-signed URLs for secure uploads.

A simple rule of thumb: default to strong consistency for critical invariants, and use eventual consistency for derived or cached views.

Back-of-the-Envelope Numbers (Capacity Planning)

Showing quick math signals seniority. Keep it simple and round numbers.

Traffic: If you expect 10 million daily active users with 20 feed views/day, that’s ~200M feed reads/day ≈ 2,300 reads/second on average (peaks can be 10×).
Storage: If average image is 500 KB and 5 million posts/day, that’s ~2.5 TB/day. Plan for lifecycle rules (cold storage) to control cost.
Cache sizing: If 20% of posts drive 80% of reads, cache those aggressively to offload the DB.

Call out that you’d validate these assumptions with metrics and adjust capacity accordingly.

Example Walkthrough: “Instagram‑Lite” (Upload + Feed)

Here’s how you could structure a 30, 40 minute discussion.

1) Clarify scope

We’ll design uploading a photo and viewing a personalized feed. No messaging. Single region to start.

2) Requirements

Functional: upload post, view home feed, like post
Non-functional: low-latency feed (<200 ms p95), handle bursts, durable media

3) API + Data

APIs: POST /posts, GET /feed, POST /likes
Data: relational DB for Users, Posts, Follows; cache for hot feeds; blob storage for images; CDN for delivery

4) Baseline architecture

App servers behind a load balancer
Separate read and write pathways
DB for metadata; object storage for images; CDN in front of storage

5) Scale up

Precompute feeds via background workers using the Follow graph
Store precomputed feed pages per user in cache with TTL; fall back to on-demand fetch if missed
Use idempotency keys for POST /posts and POST /likes
Add metrics: feed latency, cache hit ratio, DB QPS, queue depth

Trade-offs to discuss

Precomputed feeds are fast but expensive for high-fanout users; on-demand feed assembly is cheaper but slower
Likes may be eventually consistent in the UI to keep writes simple and fast
Hot content mitigation: rate limit likes/comments on viral posts and partition workload

Close with a brief summary and note what you’d do “with more time” (multi-region, stronger privacy, ranking models).

How to Communicate During the Interview

Start simple, then layer. Don’t jump to Kubernetes or global replication immediately.
State assumptions aloud and check if they’re okay.
Draw while you talk; name each component and its purpose.
Keep a running list of trade-offs you’ve discussed.
Time-box: spend ~5 minutes on scope, ~10 on APIs/data, ~10 on architecture, ~10 on scaling and trade-offs, and reserve a few minutes to recap.

Practice Plan: Build Your System Design “Muscle Memory”

Do mock interviews weekly. Record yourself to spot gaps.
Keep a design journal with recurring patterns (caching strategies, idempotency, queues).
Rehearse common scenarios: news feed, rate limiter, URL shortener, chat, notifications, search, analytics pipeline.
Turn designs into small artifacts you can reuse: API templates, capacity cheat sheets, and a quick checklist.

To put these steps into practice and find platforms for mock interviews and hands-on exercises, check our guide to learn coding platforms that lists resources for practicing system design problems.

Common Mistakes to Avoid

Designing the whole company: Focus on one slice that shows depth.
Ignoring non-functional requirements: Talk latency, availability, and durability.
Over-optimizing early: Start with a clean baseline, then scale.
Hand-waving data: Share basic back-of-the-envelope estimates.
Vague trade-offs: Name the cost of your choice and why it’s acceptable.
Skipping observability and safety: Always include metrics, logs, rate limits, and basic security.

Key Takeaways

System design is about clarity, trade-offs, and communication, not buzzwords.
Start with scope and requirements, then APIs/data, then a simple architecture you can scale.
Use caches, queues, and CDNs to meet latency and throughput goals.
Be explicit about consistency choices and where eventual consistency is acceptable.
Practice with a repeatable framework and keep improving your artifacts.

Conclusion

System design interviews reward simple, clear thinking. Focus on the user flow you’re building, define functional and non-functional requirements, sketch clean APIs and data models, present a baseline architecture, and then layer scale and reliability with clear trade-offs. With practice and a steady structure, you’ll walk into every Interview ready to show sound engineering judgment, connecting Coding skills to real-world systems that serve millions.

Pnpm: Faster, Leaner Node.js Package Manager - Save Disk

Robort Gabriel — Sat, 20 Sep 2025 13:51:54 +0000

If you’re still installing dependencies with Npm or Yarn, you might be donating minutes and gigabytes you’ll never get back. I switched one noisy repo to Pnpm (pnpm) and my laptop fan basically retired on the spot. It speeds up installs and skips duplicating the same packages across projects, without making you relearn your whole workflow.

Why developers are switching to Pnpm

Speed that scales: Often clearly faster on fresh installs and in CI, and the gap widens as repos grow.
Huge disk savings: Instead of duplicating the same library in every node_modules, pnpm reuses a single copy across projects.
Fewer surprises: A stricter, more accurate dependency layout helps prevent “it works on my machine” mysteries.
Great for monorepos: First-class workspace support keeps multi-package projects tidy and consistent.

According to the official Motivation page, pnpm stores packages in a global, content‑addressable store and links them into each project. That’s why disk usage drops and installs get faster as you add more projects on the same machine.

How Pnpm works (in plain English)

Traditional managers copy dependencies into every project’s node_modules. Pnpm instead:

Downloads a package version once into a global content-addressable store on your machine.
Adds hard links/symlinks from your project’s node_modules back to that store.
Builds a non-flat, accurate dependency tree (you’ll notice a virtual store under node_modules/.pnpm) that mirrors how packages actually depend on each other.

The result: less disk I/O, less duplication, and cleaner isolation between direct and transitive dependencies. Think fewer “where did that dependency come from?” moments.

Real-world performance: what to expect

While results vary by project and CI setup, tests from large monorepos show a clear pattern:

Yarn 2: around 6.5 minutes on a cold cache; about 1.2 minutes warm
Yarn 3 (tuned): around 1.2 minutes cold; ~45 seconds warm
Pnpm: around 58 seconds cold; ~24 seconds warm

These numbers are from one detailed case study; your mileage will vary. Still, the trend holds: pnpm shines during cache misses and stays snappy with a warm cache.

Pnpm vs Npm vs Yarn: quick comparison

Category	Pnpm	Npm	Yarn
Install speed	Very fast (cold and warm)	Solid, but slower on large graphs	Fast; Yarn 3 can be very competitive
Disk usage	Minimal duplicates via global store + links	Duplicates per project	Duplicates per project (unless using advanced modes)
node_modules layout	Nested, accurate; virtual store under `.pnpm`	Flat hoisted	Flat hoisted by default
Dependency isolation	Strict, avoids phantom deps	Can allow undeclared access via hoisting	Can allow undeclared access via hoisting
Workspaces/monorepos	Built-in and ergonomic	Supported	Supported, powerful
Learning curve	Light; new layout/commands	Very familiar	Familiar; advanced features add complexity

Getting started with Pnpm (5 steps)

1) Install pnpm globally

Using Npm: npm install -g pnpm
Or via Corepack (Node 16.13+): corepack enable && corepack prepare pnpm@latest --activate

2) Clean the project

Remove prior artifacts: rm -rf node_modules package-lock.json yarn.lock

3) Import lockfile (optional)

From npm or yarn: pnpm import

4) Install deps

pnpm install

5) Update scripts and docs

Replace commands like npm run with pnpm run where appropriate.
In monorepos, create a pnpm-workspace.yaml with your package globs.

Pro tip: Use one package manager per project. Commit pnpm-lock.yaml and document the choice for your team.

Common migration pitfalls (and fixes)

Undeclared dependencies break builds
- Why it happens: pnpm’s strict layout blocks access to packages you didn’t declare.
- Fix: add the missing dependency explicitly, or (as a last resort) use hoisting options like public-hoist-pattern/shamefully-hoist for tools that expect a flat layout.
Tools that don’t follow symlinks well
- Some build tools or CLIs assume a flat node_modules. Add the exact dependency to the workspace using it, or enable limited hoisting for that package.
CI caching feels “off”
- Ensure you cache pnpm’s global store directory and pnpm-store paths. Always restore cache before pnpm install.
Team muscle memory
- Create a local alias, e.g., alias pn=pnpm, and share a short command map (see below) in your README.

Command cheat sheet (Npm/Yarn → Pnpm)

Install all: npm install / yarn install → pnpm install
Add a prod dep: npm i lodash / yarn add lodash → pnpm add lodash
Add a dev dep: npm i -D typescript / yarn add -D typescript → pnpm add -D typescript
Remove: npm uninstall pkg / yarn remove pkg → pnpm remove pkg
Update: npm update / yarn upgrade → pnpm update
Run script: npm run build / yarn build → pnpm run build
Workspaces: npm -w pkg run test / yarn workspace pkg test → pnpm -F pkg run test

Best practices for smooth adoption

Standardize on pnpm per repo; don’t mix managers.
Commit pnpm-lock.yaml and review it in PRs.
Keep Node and pnpm up to date across dev machines and CI.
In monorepos, define clear workspace globs and use pnpm -r for repo-wide commands.
Cache the pnpm store in CI and restore it early in the pipeline.

Should you use Pnpm?

Choose the right tool for your context:

Pick Pnpm if you manage large projects or monorepos, want faster fresh installs, or have limited disk space.
Stick with Npm for maximum compatibility and if your project is small and simple.
Consider Yarn if your team already standardizes on it and benefits from its specific features.

For many teams, a quick trial is enough: convert one repo, measure install times (cold and warm), and check disk usage. If the results mirror what others report, faster installs and smaller footprints, roll Pnpm out more widely.

Conclusion

Pnpm delivers faster installs, strict and reliable dependency resolution, and real disk-space savings. If you juggle multiple projects or a monorepo, it’s one of the easiest wins you can land this quarter. Try Pnpm on a single repository, measure the difference, and see if it earns a permanent spot in your toolkit.