This is a submission for the Gemma 4 Challenge: Write About Gemma 4

Okay, let me be honest with you for a second.

I’m tired of AI comparison posts that read like a press release had a baby with a spreadsheet. You know the ones. Big table. Green checkmarks. “Model X wins for enterprise use cases.” Thanks, very useful, completely useless.

So let me try something different. Let me tell you what I actually found after spending time digging into Gemma 4, Claude, and Llama 4 in 2026 — what surprised me, what annoyed me, and where each one genuinely earns your trust or loses it.

Because the honest answer is: it depends, but not in the way you think.

First — What Even Is Gemma 4?

If you haven’t been paying attention, Google DeepMind dropped Gemma 4 on April 2, 2026 and it quietly started breaking things.

Not in a bad way. In the “wait, this runs on what?” way.

Gemma 4 isn’t a single model. It’s a family:

• E2B (~2.3B effective params) — designed for phones and Raspberry Pi. Yes, literally your Pi.
• E4B (~4.5B effective params) — the sweet spot. Runs on integrated graphics or any 8GB+ GPU.
• 26B A4B MoE — 26 billion total params, but only 3.8 billion active per inference thanks to Mixture-of-Experts routing. One A100 80GB can serve it.
• 31B Dense — the big gun. All params active, maximum quality.

All of it built on the same research foundations as Gemini 3. All of it released under Apache 2.0. No MAU limits. No special permissions. No restrictive use clauses. Just: here, use it.

That last bit matters more than people are giving it credit for.

The Numbers Nobody’s Contextualizing

Let me throw some benchmarks at you, but I’m actually going to explain what they mean:

Gemma 4 31B on AIME 2026 (math): 89.2%

For context, Gemma 3 27B scored 20.8% on the same test. That’s a +330% jump. Not incremental. Not a rounding error. Something fundamentally changed.

LiveCodeBench v6: 80%

Gemma 3 was at 29.1%. So you’re looking at 175% improvement in coding benchmarks in one generation.

Codeforces ELO: 2,150

That’s expert competitive programmer territory. Running locally. On your machine.

Agentic Tool Use (τ2-bench Retail): went from 6.6% to 86.4%

That’s +1200%. The model went from basically failing at multi-step tool use to crushing it. This is the benchmark I’d bet money on being the most meaningful one for 2026 workflows.

The 31B Dense model currently sits at #3 on the Arena AI text leaderboard among all open models — outcompeting models with 20x more parameters.

And look — I know benchmarks lie sometimes. I know labs cherry-pick. But when every benchmark jumps by 100-300% simultaneously, that’s not cherry-picking. Something real happened here.

Claude: The One You Pay For (And Why You Still Might)

Let me be clear: I respect what Anthropic has built. Claude is genuinely different from most models in ways that are hard to benchmark.

As of early 2026, the main Claude options are:

• Sonnet 4.6 — $3/$15 per million tokens. 79.6% on SWE-bench Verified.
• Opus 4.6 — $5/$25 per million tokens. 80.8% on SWE-bench Verified.
• Opus 4.7 — $5/$25 per million tokens. 87.6% on SWE-bench Verified. Released April 16, 2026.

The gap between Sonnet 4.6 and Opus 4.6 is 1.2 percentage points on the benchmark that matters most for developers. That’s it. One point. At 40% lower cost and 17% faster output. Most production teams route 80% of work to Sonnet and reserve Opus for the genuinely hard stuff.

Cursor’s co-founder called Sonnet 4.6 “a notable improvement over Sonnet 4.5 across the board, including long-horizon tasks.” GitHub reported strong performance on complex code fixes. Cognition said it “meaningfully closed the gap with Opus on bug detection.”

So what’s the catch?

Claude has no weights. Full stop.

You cannot run Claude locally. You cannot fine-tune it on your data. You cannot deploy it on your own infrastructure. There’s no local option, no open version, nothing. It’s a pure API play.

Constitutional AI baked into the architecture means you will occasionally hit refusals that feel arbitrary — requests the model could handle but won’t. The reason-based constitution introduced in January 2026 made these responses more nuanced, but you’ll still encounter them if you push edge cases.

The 200K context window is solid. The 1M beta (via header) is there for Opus if you need it. But if your use case requires data sovereignty, EU compliance, or offline deployment? Claude is a non-starter. Full stop. No negotiation.

Llama 4: The “Free” Option That Has Fine Print

Meta dropped Llama 4 in early 2026 and the internet exploded. Two models released:

• Scout — 17B active params (16 experts), 10M context window. Fits on a single H100.
• Maverick — 17B active params (128 experts). 400B total params. The flagship.

The 10 million token context window on Scout is genuinely staggering. Nothing else touches it. If you need to feed an entire codebase, years of logs, or a library of documents into a single context — Scout is the only realistic option today.

Maverick is positioned as a generalist, and for everyday writing, analysis, and conversation? It’s good enough that the quality gap versus paid models often doesn’t justify the cost.

But here’s what doesn’t get talked about:

The benchmark gaming incident. In April 2025, Meta submitted a variant called “Llama-4-Maverick-03-26-Experimental” to LMArena. It topped the leaderboard. The public release performs noticeably worse. LMSYS later acknowledged the variant wasn’t labeled clearly. Meta’s VP denied training on test sets. The AI community read it as benchmark gaming regardless. Until that trust is rebuilt, take any single LMArena number for Llama 4 with healthy skepticism.

The license isn’t what you think. It looks open. It isn’t OSI-certified open source. There’s a 700M MAU clause — if your service exceeds 700 million monthly active users, you need a separate Meta license. For most devs that’s irrelevant. But it also means you can’t legally call it Apache or MIT. Attribution requirements exist on derivatives. Enterprise legal teams in regulated industries will flag this.

EU multimodal restriction. Vision is unavailable for EU-domiciled licensees. Hard block.

Hardware reality. Llama 4 Scout needs 24GB VRAM minimum even quantized. Gemma 4 E4B runs on 6-8GB. If you’re on a laptop or consumer GPU, this comparison basically ends here.

Llama 4 on coding specifically? It’s competitive but not dominant. If your primary workload is code generation or agentic refactoring, it’s not the strongest open-weight choice in 2026.

The Comparison Nobody Actually Makes

Let me put this plainly, because most posts won’t:

The real trade-off isn’t quality. It’s the question of: *who controls the model?*

Where Gemma 4 Actually Wins the Argument

The thing that keeps pulling me back to Gemma 4 isn’t the benchmark numbers. It’s the combination of things nobody else is offering together:

Edge-to-server coverage under one license. E2B runs on a Raspberry Pi at ~48 tokens per second on a ROG Phone 9 Pro. The 31B Dense runs on a workstation. The 26B MoE runs on a single A100. One model family. One license. One mental model for your entire stack.

The Apache 2.0 shift is a big deal. Earlier Gemma releases had custom licenses that enterprise legal teams routinely flagged as ambiguous. Apache 2.0 means: modify it, fine-tune it, deploy it commercially, redistribute derivatives — no royalties, no MAU limits, no acceptable use policy headaches. In 2026, as companies build always-on AI agents that process customer data continuously, the licensing terms of the underlying model are a strategic decision. Gemma 4 made that decision easy.

Multimodal natively, not bolted on. Text, image, video, audio — not as separate pipeline steps, but as native capabilities built from the Gemini 3 foundation. The smaller models (E2B, E4B) support video and audio. The larger models handle all modalities. This matters for real applications, not benchmark demos.

The reasoning jump is real. When Gemma 4 “thinks,” it can produce 4,000+ tokens of reasoning before committing to an answer. The Codeforces ELO of 2,150 puts it at expert programmer level — locally, on your GPU, free.

The Honest Verdict

If I had to give you one paragraph:

Use Claude when you need the absolute ceiling on reasoning and you’re okay with API costs, black-box architecture, and no local option. Sonnet 4.6 is the value play; Opus 4.7 is for the problems that genuinely require the best thing available.

Use Llama 4 Scout when you need the 10M token context window and you have the hardware for it. For everything else, its coding performance lags and the licensing is messier than it looks.

Use Gemma 4 when you want the freedom to actually own your AI stack. Run it on a phone for edge apps, a consumer GPU for development, a workstation for production — all with the same model family, the same license, the same mental model. The performance is now genuinely competitive at frontier level. The agentic tool use numbers in 2026 suggest it’s not just catching up; in specific areas, it’s already leading.

The era of “open source AI is just good enough to tinker with” is over.

Gemma 4 31B sitting at #3 on Arena AI, outscoring models with 20x the parameter count, running on hardware you already own, under a license that puts zero friction between you and shipping — that’s not a compromise. That’s just the better option for most use cases.

The question isn’t “which model is best” anymore.

The question is: which model fits the kind of developer you want to be?

If your answer involves ownership, privacy, cost control, and the freedom to deploy wherever you want — the answer in 2026 is becoming increasingly obvious.

References:

• Gemma 4 Complete Guide 2026 — AurigaIT
• Gemma 4 Benchmarks: The Numbers That Actually Matter — Medium
• Gemma 4 vs Llama 4: Local Deployment 2026 — CoderSera
• Claude Opus 4.7 Benchmarks — The AI Corner
• Claude Sonnet 4.6 Specs — ClaudeFast
• Llama 4 Complete Developer Guide 2026 — CoderSera
• Meta Llama 4 Official Blog
• Gemma 4: How a 31B Model Beats 400B Rivals — Tech Insider

You can find me across the web here:

• ✍️ Read more on Medium: @syedahmershah
• 💬 Join the discussion on DEV.to: @syedahmershah
• 🧠 Deep dives on Hashnode: @syedahmershah
• 💻 Check my code on GitHub: @ahmershahdev
• 🔗 Connect professionally on LinkedIn: Syed Ahmer Shah
• 🧭 All my links in one place on Beacons: Syed Ahmer Shah
• 🌐 Visit my Portfolio Website: ahmershah.dev

Serie: Bitácora de Macchiato

Hoy no tomé café. Tomé Macchiato.

Tengo cuatro proyectos abiertos ahora mismo. Vue, Spring Boot, un worker en Node y el landing de Guayoyo. Cada uno usa Claude Code o OpenCode dependiendo del día, del ánimo, de qué CLI no rompió algo esa semana.

El ritual es siempre el mismo y siempre me rompe las pelotas: cd ~/projects/loquesea, which claude — no, era OpenCode — y cuando arranca el CLI ya perdí el hilo.

La fricción no está en usar la IA. Está en llegar a usarla. Entre la idea y el prompt hay un desierto de navegación de directorios, verificación de instalaciones y contexto perdido.

Así que en vez de putear la terminal una vez más, abrí Electron.

Día 1 entregó:

• Shell PTY completo dentro de Electron (no un wrapper — una terminal real)
• Detecta Claude Code y OpenCode automáticamente en tu PATH
• Cada CLI en su propia pestaña con contexto independiente
• Persistencia con SQLite — cierras, abres, retomas donde estabas
• Cero dependencias externas. Tu data es tuya.

Próximamente en guayoyo.tech. Gratis para empezar, porque nadie debería pagar por abrir su propia terminal con un botón.

— Jesús Manrique, construyendo en voz alta desde Caracas.

This is a submission for the Hermes Agent Challenge

What I Built

I built hermes-skill-hq, a skill knowledge base for Hermes Agent.

The problem it solves is simple: once an agent has access to hundreds or thousands of skills, the hard part is no longer “can the agent do this?” It becomes “does the agent know the right skill exists, and will it load it before improvising?”

Hermes Skill HQ gives the agent a structured operating model for that:

1. Navigator — map a task to the right skill quickly.
2. Advisor — proactively notice when a skill would help.
3. Authoring companion — identify gaps and help create new skills when no good one exists.

Instead of treating skills as a passive folder of files, HQ turns them into an active knowledge base. It tells the agent where to look first, when to stop searching, how to avoid wasting context, and how to maintain the index over time.

In practice, it helps Hermes answer questions like:

• “Is there already a skill for this task?”
• “Should I load a specific workflow before touching files?”
• “Is this a missing skill we should author?”
• “How do I keep the skill catalog from becoming stale?”

Demo

A typical interaction looks like this:

User: Help me set up a ComfyUI workflow.
Hermes: Checked HQ's INDEX — there is a ComfyUI skill for image, video, and audio workflows. Want me to load it before we continue?

Or, when no skill exists:

User: I want to automate a workflow for a tool HQ has never seen.
Hermes: INDEX has no match. Hub search has no match. That looks like a gap. Want me to create a new skill and validate it with skill-creator?

The important part is not the wording; it is the behavior. Hermes stops guessing. It checks the knowledge base first, explains what it found, and either loads the right skill or identifies a skill gap.

Code

Repository:

The project is designed to live at the standard Hermes knowledge-base path:

git clone https://github.com/CodeSigils/hermes-skill-hq.git ~/.hermes/kb

Then it can be added to Hermes through external_dirs:

external_dirs:
  - ~/.hermes/kb

After refreshing Hermes, the knowledge base becomes available as a normal skill named hermes-skill-hq.

My Tech Stack

• Hermes Agent
• Agent Skills / SKILL.md format
• Markdown knowledge base files
• A curated task-to-skill index
• Local Hermes hub cache with roughly 2,000 skills
• External skill marketplace references
• GitHub for versioning and distribution

The repo is intentionally lightweight. Most of the value is in the structure and the operating contract, not in a big application framework.

How I Used Hermes Agent

Hermes Agent is both the runtime and the development environment for this project.

I used Hermes to inspect the existing skill ecosystem, compare local skills against hub and marketplace sources, update the task-to-skill index, trim overly large references, and keep the documentation accurate. The agent was especially useful for repetitive knowledge-maintenance work: searching files, checking stale references, editing Markdown, validating instructions, and updating related skill docs when a workflow changed.

The most useful agentic capabilities were:

• Tool use: Hermes could inspect the repo, read source files, search across the knowledge base, and apply targeted edits.
• Persistent skills: Workflows that proved useful could be turned into reusable skills instead of being re-explained every session.
• Memory and session continuity: Hermes could remember durable conventions, like the canonical install path ~/.hermes/kb/, while avoiding stale task-progress notes.
• Skill loading: The project depends on the idea that agents should load specialized instructions before acting. HQ makes that behavior explicit and systematic.
• Self-improvement loop: When Hermes finds a gap, it can help author a new skill, validate it, and add it back into the index.

Hermes Skill HQ is essentially a meta-skill: it helps Hermes decide which other skill to use. That makes the agent more reliable, less ad hoc, and more transparent about why it is choosing a particular workflow.

The design goal is not to make the agent read everything. In fact, a major part of the project is teaching the agent when to stop. HQ uses a layered search strategy: check the index first, search the hub second, and only expand to marketplaces when simpler sources fail. That keeps context usage under control while still giving the agent a path to deeper discovery when needed.

For me, that is the core value: Hermes Skill HQ turns a large pile of reusable capabilities into a navigable, maintainable system.

I used to start every morning the same way: open Gmail, feel immediately overwhelmed, spend 40 minutes triaging emails that turned out not to matter — and then miss the one thing that actually did.

So I built Jigeum — an AI Chief of Staff that reads your inbox, scores every signal by urgency, and surfaces only what needs you. This is the architecture, the honest failures, and what actually changed my routine.

The first version completely failed

My original product was called EVE. The pitch: “AI employee — connect your tools, EVE handles the rest.”

It was too broad. Every demo, people nodded politely. Nobody knew what to do with it. I shipped features — Slack integration, task management, autonomous agent loops — but the core value proposition was muddy. Four months in, I was the only person using it daily.

Every morning I’d open it and quietly ask myself: why am I actually using this?

That question cracked it open.

The real problem: attention is the bottleneck

The problem isn’t having too many emails. It’s that every notification competes for the same finite resource: your decision-making capacity.

A GDPR newsletter. A contract waiting for signature. A customer reporting a critical bug. A LinkedIn request. Your inbox treats them identically.

I renamed the product Jigeum (지금 — Korean for right now) and rebuilt around a single question: what needs my attention right now, and what doesn’t?

Architecture: the Attention OS

The core model is a 5-tier escalation system. Every incoming signal — email, calendar event, extracted commitment — gets classified before it ever reaches me:

SILENT    → don't surface, don't notify
QUEUE     → add to review list, no interrupt
PUSH      → mobile push notification
CALL      → urgent interrupt (not yet built)
AUTO      → handle automatically without asking

I call this the Attention Firewall. Before anything reaches my conscious attention, it passes through classification.

Trust Score

Each sender gets a Trust Score (0–100). Higher score means more likely to escalate. It’s derived from:

• Historical reply frequency
• Whether I’ve responded before, and how fast
• Explicit feedback (“always notify me from this person”)
• Domain-level signals (my own domain scores higher than cold outreach)

interface TrustScore {
  userId: string;
  contactEmail: string;
  score: number;               // 0–100
  interactionCount: number;
  avgResponseMinutes: number | null;
  lastInteractionAt: Date | null;
}

A newsletter I’ve never replied to scores ~10. My co-founder scores 95. The escalation tier is calculated from trust score combined with content analysis of the email itself.

Voice Profile

The AI needs to know how I communicate, not just what to do. Voice Profile stores the patterns extracted from my sent mail:

interface VoiceProfile {
  userId: string;
  tone: string;                // "direct", "warm", "formal"
  signatureStyle: string;
  preferredLength: "short" | "medium" | "long";
  phrases: string[];           // things I actually say
  avoidPhrases: string[];      // things I never say
}

When drafting a reply suggestion, the AI pulls this profile. The goal is that a suggested reply reads like me — not like a generic AI assistant.

Commitment Ledger

This is the feature that made me realize the product had real value.

Every email where I wrote “I’ll send this by Friday” or “Let me get back to you next week” — those are commitments. They disappear into threads. I forget them. The other person doesn’t.

The commitment extractor runs on every processed email and populates a ledger:

interface Commitment {
  id: string;
  userId: string;
  title: string;
  kind: "DELIVERABLE" | "MEETING" | "FOLLOW_UP" | "DECISION";
  owner: "USER" | "COUNTERPART";
  dueAt: Date | null;
  dueText: string | null;      // "by Friday", "next week"
  confidence: number;          // 0–1
  status: "OPEN" | "DONE" | "OVERDUE";
}

The confidence field matters a lot. “Let’s sync sometime” → confidence 0.3, stays quiet. “Please send the NDA by Tuesday EOD” → confidence 0.9, surfaced immediately in the Command Center.

The Command Center

The UI is a single page. This replaced my inbox as the first screen I open each morning.

Layout (left → right on desktop):

• Morning Briefing — AI summary of what happened overnight and what needs attention today, full width at top
• Approval Queue — actions Jigeum wants to take but needs my sign-off first
• Commitment Ledger — things I promised, things others promised me
• Reply Needed — emails where someone asked a direct question

The Reply Needed surface was the hardest to get right. Naive approach (detect ? in email body) had terrible precision — questions in automated receipts, rhetorical questions, quoted threads all triggered false positives.

What actually works: question detection + sender trust weighting + thread position analysis (a question in the first email of a thread means something different than the same question in reply #5).

// GET /api/inbox/reply-needed
const rows = await prisma.emailMessage.findMany({
  where: { userId, needsReply: true },
  orderBy: [
    { needsReplyConfidence: "desc" },
    { receivedAt: "desc" }
  ],
  take: 8,
  select: {
    id: true,
    subject: true,
    from: true,
    snippet: true,
    needsReplyReason: true,
    needsReplyConfidence: true,
    receivedAt: true,
  },
});

Tech stack

One thing I’d do differently: Gmail sync architecture. I built polling with historyId-based incremental sync when I should have used Gmail Push Notifications from day one. The polling works but introduces ~30s latency on new emails. That latency matters when something urgent arrives.

What failed (honestly)

Notification flood. The early version pushed a notification for every signal classified as PUSH tier. Within 24 hours I had disabled push notifications on my own app. Had to rebuild with rate limiting — same-sender notifications within 15 minutes now collapse into one.

Over-trusting AUTO. The autonomous tier where Jigeum acts without asking me — I thought I wanted this. Turns out I don’t trust it yet. I’ve pulled AUTO back to only unsubscribes and read-receipts. Anything that involves sending a message or making a decision goes through the Approval Queue.

The rebrand was a distraction. Spent a full week renaming EVE → Jigeum across the codebase, updating marketing copy, redoing the landing page. The code ran identically after. Should have shipped instead.

Mobile doesn’t exist yet. It’s web-only. For something meant to filter morning attention, the fact that you have to open a browser tab is a real friction point. Working on it.

Four weeks of dogfooding — what actually changed

• I check the Commitment Ledger before every morning standup. It’s caught 3 things I would have genuinely dropped.
• Reply Needed reduced my inbox-zero anxiety. If something actually needs me, it surfaces there. If it’s not there, I’m not missing anything.
• Morning Briefing saves roughly 20 minutes of triage per day.
• The AI still occasionally misclassifies cold outreach as high-priority. Trust Score calibration is ongoing.

Try it

Jigeum is in private beta at hire-eve-web.vercel.app. Connect Gmail + Calendar, initial sync takes about 30 seconds.

If you’re a founder, solo operator, or anyone who feels like their attention is being managed by their inbox rather than by themselves — I’d genuinely value the feedback. Especially where it gets the classification wrong.

Happy to answer architecture questions in the comments.

Built solo. Stack: Next.js, Fastify, PostgreSQL, Gmail API, and a lot of OpenRouter credits.

I build WhatsApp automation for small businesses, and in 2026 the first thing you notice about the market is how similar every offer looks. A dozen vendors, the same promises — 24/7 replies, appointment booking, lead capture — and quotes that all cluster in the same range.

After several years of these projects, the pattern is clear: the expensive mistakes are almost never in the build itself. They are in the buying decision — the questions nobody asked before signing. Here are the five that account for most of the regret.

Trap 1 — Judging the quote by its setup price

The visible number on a bot quote is the one-time build fee. In the market I work in (Israel), that is broadly ₪3,500 for a basic bot, around ₪6,500 for a mid-tier with CRM integration, and ₪12,000+ for a full AI agent. Buyers line those numbers up and pick the lowest.

But the setup fee varies least between serious vendors. What actually decides whether the bot is cheap or expensive over three years is the recurring cost: per-message template fees, language-model usage, hosting, maintenance. A bot with a low setup fee and an unexamined monthly tail can cost more over two years than a pricier build with a lean tail. Ask for the three-year total, not the sticker.

Trap 2 — Not asking which API the bot runs on

This is the single most consequential question, and most buyers never ask it.

A WhatsApp bot connects in one of two ways: through Meta’s official WhatsApp Business API, or through an unofficial route that automates the regular WhatsApp app (the best-known open-source project here is WAHA). The unofficial route is genuinely cheaper — no per-message fee — and at low volume it works.

It also runs against Meta’s terms of service, and the number it runs on can be suspended without warning or appeal. For most businesses the WhatsApp number is the customer database and the primary contact channel. Losing it is not an inconvenience; it is a small catastrophe. The unofficial route is reasonable for narrow cases — internal tools, low-stakes notifications — but you should know which one you are buying, and why. A quote that doesn’t specify is a quote to question.

Trap 3 — Paying for AI the bot will never use

“AI-powered” is the headline tier on most 2026 quotes. It is also the tier most often sold and least often delivered — not because vendors cut corners, but because an AI bot is only as good as what it is given.

A language model wired to WhatsApp but never fed the business’s real price list, policies, hours, and tone will underperform a plain, well-built menu bot. The capability is real; it just isn’t automatic. Before paying the AI premium, ask the concrete question: what exactly will the model be given to work from, who assembles that, and who keeps it current. If the answer is vague, you’re buying a label.

Trap 4 — Treating the bot as build-once

A WhatsApp bot is not an appliance. It is software sitting on top of three things that move constantly — Meta’s platform, the automation tooling, and the AI models underneath.

The pace is not theoretical. Inside one 90-day window in 2026, Meta repriced its message templates, n8n shipped native AI-agent capability, the major model vendors cut their cheapest production models by 40–60%, and Meta’s WhatsApp Calling API reached general availability. A bot specified in early 2025, on early-2025 assumptions, is already running on stale economics. Either budget for maintenance, or budget — unknowingly — for a rebuild.

Trap 5 — No exit ramp to a human

The last trap is the most human one. A bot with no clean handoff to a person frustrates customers more than no bot at all — everyone has been stuck in a loop with an automated system that won’t let them out.

The measure of a well-built bot is not how many conversations it handles end to end. It is how gracefully it recognizes the ones it cannot, and how fast it puts a real person in the chat. Ask any vendor to walk through exactly what happens when the bot doesn’t know the answer.

What good looks like

A strong vendor’s quote answers all five of these before you think to ask — it states the API, breaks out the recurring costs, is specific about what the AI is fed, includes a maintenance path, and treats the human handoff as a feature, not an afterthought.

If you want the longer version — the bot types, the official-vs-unofficial API tradeoff in detail, and current pricing — I keep a full guide here: WhatsApp Bot for Business: the complete guide.

The market is crowded, and from the outside the offers really do look alike. They stop looking alike the moment you ask the five questions.

I run an automation consultancy focused on WhatsApp chatbots, n8n workflows, and CRM integrations for small businesses.

This post is my submission for DEV Education Track: Build Apps with Google AI Studio.

What I Built

Demo

My Experience

This post is my submission for DEV Education Track: Build Apps with Google AI Studio.

What I Built

Demo

My Experience