DEV Community: Alden Menzalji

Hermes vs OpenClaw vs Claude Code: Which Should You Run in 2026?

Alden Menzalji — Wed, 12 Aug 2026 09:27:37 +0000

Short answer: OpenClaw for reach, Hermes Agent for an agent that learns

Verified August 12, 2026. TL;DR: Hermes Agent and OpenClaw are the same category, MIT-licensed personal assistants you host yourself and point at whatever model you pay for. OpenClaw reaches further across your chat apps and your devices. Hermes is built to accumulate skills from the work you repeat. Each ships a one-command importer for the other, so the trial is cheap. Claude Code is here by search habit: proprietary, and for codebases.

	Hermes Agent	OpenClaw	Claude Code
Licence	MIT, Nous Research	MIT, OpenClaw Foundation	Proprietary, all rights reserved
Best for	Recurring jobs that should improve	An assistant in your chats and on your devices	Codebases, commits, PRs
Runs on	Local, Docker, SSH, Singularity, Modal, Daytona, Vercel Sandbox	macOS, Linux, Windows, plus companion apps	Terminal, IDE, desktop, web, mobile
Model	Any provider, switch with `hermes model`	Hosted or local, your pick	Anthropic's Claude models
Cost	Free software, you pay for model access	Free software, you pay for model access	A paid Claude plan or Console account

Each ships a one-command importer for the other

Switching is cheap in both directions, which is rare. Hermes ships hermes claw migrate, and its setup wizard detects ~/.openclaw and offers to migrate before configuration begins. OpenClaw ships the mirror: openclaw migrate hermes is a bundled provider that follows HERMES_HOME, previews every change, redacts secrets in its plans, and writes a verified backup. Try either for an evening. The one thing that does not travel is the learning loop.

Hermes bets on a learning loop

Nous Research calls Hermes "the only agent with a built-in learning loop": it creates skills from experience, improves them during use, searches its own past conversations, and builds a model of you through Honcho. That is the vendor's claim, not a benchmark. Tellingly, OpenClaw's importer records external memory providers such as Honcho as archive or manual-review items rather than migrating them. Your skills move. The model of you does not.

OpenClaw bets on reach

OpenClaw's Gateway connects WhatsApp, Telegram, Slack, Discord, Google Chat, Signal and iMessage, among others, and companion apps add voice, Canvas, camera and screen on supported platforms. Hermes covers Telegram, Discord, Slack, WhatsApp, Signal, Email and its own CLI, and runs across seven terminal backends, of which Daytona and Modal hibernate when idle. Both install on macOS, Linux and Windows. OpenClaw pushes onto more devices; Hermes pushes further off them.

Self-hosting hands you the security bill

Both are honest about it, which I respect. OpenClaw says tools "run on the host for the main session unless you configure sandboxing", and DM-capable channels pair unknown senders by default. Hermes documents eight security layers, with dangerous-command approval in smart, manual or off modes, and cron jobs set to deny by default when they hit one. Claude Code leaves that work with Anthropic. That is the trade you are making.

How to pick

Happy with OpenClaw's channel coverage and its reach onto your devices? Stay. Want an agent that compounds on recurring work, on a box that is not your laptop? Try Hermes, and keep the migration dry-run. For the hosted alternative to both, read Claude Cowork vs Claude Code vs OpenClaw, and for a tighter permission model see the OpenWorker comparison. Neither is a coding agent: start with Codex vs Claude Code vs GitHub Copilot for that. Founders still deciding whether to write the code at all should start with the vibe code or hire check.

References

GitHub. NousResearch/hermes-agent README
Hermes Agent documentation. "Security"
GitHub. openclaw/openclaw README
OpenClaw documentation. "Migrating from Hermes"
GitHub. anthropics/claude-code LICENSE.md

Understanding Personalization Factors - Part 2: CDPs, Data Quality, and Strategy

Alden Menzalji — Tue, 11 Aug 2026 09:19:52 +0000

Your CDP promises a "single customer view." Your implementation took 14 months. And somehow, your marketing team still can't answer basic questions about customer behavior.

Welcome to CDP reality.

Hero photo by Luke Chesser on Unsplash

The Personalization Reality Check Series

Introduction to Personalization

Understanding Personalization Factors - Part 1: Data Taxonomy

Understanding Personalization Factors - Part 2: CDPs & Strategy (You are here)

Server-Side Personalization - Part 1: Architecture & Caching

Server-Side Personalization - Part 2: Performance & Decisions

Client-Side Personalization

Edge-Side Personalization

Choosing the Right Approach

Try the interactive version: the free Personalization Approach Picker turns this series into an 8-question assessment.

In Part 1, we covered the taxonomy of personalization data and what actually moves the needle vs. noise. Now let's tackle CDPs, data quality, and the strategic decisions that determine success or failure.

CDP Reality Check: Promises vs. Delivery

Customer Data Platforms represent a $15.3 billion market by 2026. Let's separate vendor marketing from reality.

What CDPs Promise

"Single customer view" - Unified profile across touchpoints
"Real-time personalization" - Instant data activation
"AI-powered insights" - Automated segmentation
"Easy integration" - Connect all systems seamlessly
"GDPR/CCPA compliance" - Built-in privacy management

What CDPs Actually Deliver

The "single customer view" reality:

CDPs create a profile, but don't fix bad data
Garbage in, garbage out - consolidation doesn't equal quality
Identity resolution requires manual configuration
Cross-device tracking is probabilistic guessing

The "real-time" reality:

Most implementations have 5-15 minute data lag
True real-time requires expensive optimization
Many use cases work fine with hourly batch updates

The "AI-powered" reality:

Most CDP "AI" is basic RFM segmentation rebranded
Useful insights require data scientists to configure
Out-of-the-box segments are generic and low-value

The "easy integration" reality:

Enterprise implementations take 6-18 months
Legacy systems require custom development
Data mapping is manual, time-consuming work

When CDPs Make Sense

Good CDP candidate:

$10M+ marketing budget (ROI requires scale)
5+ disconnected data sources
Dedicated data team for implementation
Clear use cases with measurable ROI
12-18 month commitment

NOT a good CDP candidate:

Clean data in 1-2 systems (integrate directly)
Traffic too small for segmentation (<100k monthly visitors)
Lack resources for ongoing optimization
Hoping CDP will "figure out" strategy for you

CDP Cost Reality

Enterprise CDP platforms:

Software: $120k-$500k+ annually
Implementation: $200k-$800k one-time
Internal resources: 2-3 FTE minimum
Integration costs: $50k-$200k per major system

Total first-year cost: Expect $600k-$2M for enterprise implementations.

Alternatives:

Warehouse-native CDP (Hightouch, Census): $12k-$60k/year
Composable CDP (build your own): Higher upfront, lower ongoing
No CDP (direct integrations): Free, limited scalability

Reality check: Most companies get better ROI from cleaning existing data and improving segmentation than buying a CDP.

Data Quality: The Silent Killer

Bad data ruins even the best personalization strategy.

Common Data Quality Issues

Duplicate records: Same customer has 3 profiles (different emails, devices). Result: fragmented view, redundant messages.

Outdated information: Customer moved or changed jobs, but data doesn't reflect it. Result: irrelevant personalization eroding trust.

Inconsistent formatting: Phone numbers in 5 formats, names in 3 formats. Result: failed matching, broken automations.

Missing critical fields: 60% lack email, 80% lack phone, 40% lack purchase history. Result: can't execute strategies.

Incorrect inferences: "John bought diapers, so he has a baby" (he bought a gift). Result: creepy, irrelevant messaging.

Data Quality Audit Checklist

Completeness: What % have each critical field?
Accuracy: Sample 100 records manually: what's the error rate?
Consistency: Do formats match across sources?
Timeliness: How old is the data? When last updated?
Uniqueness: How many duplicates exist?

Most companies discover data quality issues after launch, when customers report creepy experiences. Test before you scale.

The Over-Segmentation Trap

More segments doesn't mean better personalization. It often means management hell.

How Over-Segmentation Happens

You start simple:

New visitors vs. returning (2 segments)

Then marketing wants more:

3 customer types × 5 product categories = 15 segments

Then lifecycle stage:

15 × 4 stages = 60 segments

Then channel preference:

60 × 3 channels = 180 segments

Each needs unique content, campaigns, and logic. Your team can't manage it.

The Real Costs

Content burden: 180 segments need 180 messages. Content team drowns.

Testing impossible: 180 segments with 10,000 visitors = 55 visitors per segment. Can't A/B test with 55 visitors.

Performance degradation: More segments = more queries = slower pages.

The Right Level

Start with 4-8 core segments based on clear behavioral differences. Each must be:

Meaningfully distinct (different conversion drivers)
Large enough to test (minimum 1,000 members)

Validate before expanding: A/B test. Do segments respond differently? If similar, merge them.

Example (B2B SaaS):

SMB (1-50 employees): Price-sensitive, self-service
Mid-Market (51-500): Balance of price and features
Enterprise (500+): Feature-rich, compliance focus

Three segments. Distinct. Manageable.

The Creepy Line

Personalized marketing generates negative experiences for 53% of customers, who become 3.2x more likely to regret a purchase. Here's what pushes it over the line:

What Makes It Creepy

Lack of transparency - "How did they know that?"
Cross-context tracking - Ads for products searched on different device
Immediate follow-up - Email 30 seconds after cart abandonment
Location-based messages - "We see you're near our store!"
Sensitive information - Health, financial, relationship references

Real-World Disasters

Target's pregnancy prediction: Algorithm identified pregnant women from purchasing patterns, sent baby coupons. A father learned his teenage daughter was pregnant from Target's mailers before she told him. Accurate ≠ appropriate.

Retargeting fatigue: Customer searches once, gets followed by ads for weeks. Customers notice, and many start avoiding the brand entirely.

How to Avoid It

Transparency: Explain why ("Because you viewed X...")
Timing: Add delays (wait 30-60 minutes for abandoned cart)
Value exchange: Give reasons to share data
Context respect: Don't mix sensitive and non-sensitive
Less is more: Subtle beats obviously targeted

The rule: If personalization would feel creepy when customers learn how it works, don't do it.

When NOT to Collect Data

Sometimes collecting data creates more problems than it solves.

Collection Backfires

Privacy-sensitive industries: Healthcare (HIPAA), financial services, children's products (COPPA). Over-collection creates compliance risk.

Small traffic: <10,000 monthly visitors means segments too small for testing. Focus on general optimization first.

Commoditized products: Customers buy on price, not personalization. Focus on competitive pricing instead.

No analytical capabilities: Collecting data you can't analyze is waste. Build capabilities first.

Consent kills conversion: Published studies measure conversion drops from 5% to 25% depending on banner design. Sometimes friction exceeds gains.

The Minimalist Strategy

Collect only:

Data with clear, documented use case
Data you can act on within 30 days
Data customers benefit from sharing
Data you can keep accurate

Don't collect:

Data "just in case"
Data you lack capabilities to use
Data creating compliance risk
Data customers won't share willingly

For each data point, ask:

What decision will this inform?
How will it improve customer experience?
Will customers understand why we need it?
Is the lift worth the collection friction?

If you can't answer all four, don't collect it.

Privacy-First as Competitive Advantage

In a world where personalized marketing produces negative experiences for 53% of customers, being privacy-respecting is a differentiator.

The old playbook: Collect maximum data through surveillance, infer everything, target aggressively, optimize for engagement.

The new playbook: Collect minimum through value exchange, ask directly instead of inferring, personalize transparently, optimize for trust.

Companies winning with privacy-first:

Apple: "Privacy is a human right" drives brand loyalty
DuckDuckGo: Privacy focus gains market share
Basecamp: "No tracking, no ads, no BS" resonates

The strategy:

Transparent collection (tell exactly what and why)
Easy opt-out (prominent, functional controls)
Value exchange (give something for data)
Data minimization (collect only what you use)
Public commitment (make privacy part of brand)

Payoff: Higher trust, better data quality, regulatory compliance, differentiation.

The Path: Starting Simple

Phase 1: Segmentation Only (Months 1-3)

4-6 meaningful segments
A/B test to validate differences
Measure performance
Goal: Prove segmentation drives lift

Phase 2: Simple Personalization (Months 4-9)

Add recent browsing history (last 30 days)
Basic product recommendations
Personalized email from stated preferences
Goal: Show incremental lift beyond segmentation

Phase 3: Advanced Personalization (Months 10-18)

Predictive models (purchase propensity, churn risk)
Real-time behavioral triggers
Cross-channel orchestration
Goal: Optimize for lifetime value

Don't skip phases. Companies jumping to Phase 3 without mastering 1-2 fail spectacularly.

The Bottom Line

Before investing in personalization infrastructure, answer:

What are our 4-6 core segments?
What data is accurate, complete, and current?
What decisions will personalization inform?
How will we measure success beyond vanity metrics?
Do customers see value in sharing data?

If you can't answer all five, you're not ready.

Next in the series: server-side personalization, with cache nightmares, Sitecore specifics, and when it fails spectacularly.

References

Gartner (2025). "Survey Reveals Personalization Can Triple Customer Regret"

Claude Cowork vs Claude Code vs OpenClaw: Which Should You Use in 2026?

Alden Menzalji — Mon, 10 Aug 2026 09:32:56 +0000

Cowork and Claude Code share one engine, OpenClaw is the real fork

Verified August 2026.

Short answer: if the work is a codebase, use Claude Code. If it is files, documents and inboxes, use Cowork. Pick OpenClaw only when you want to own the host and choose the model yourself.

	Claude Cowork	Claude Code	OpenClaw
Best for	Files, docs, non-code work	Codebases, commits, PRs	An always-on assistant in your chat apps
Runs on	Claude desktop, web, mobile	Terminal, IDE, desktop, web	Your machine: macOS, Linux, Windows, WSL2
Model	Anthropic's	Anthropic's, or third-party on CLI and VS Code	Hosted or local, your pick
Entry cost	A paid Claude plan	A paid Claude plan or Console account	Free software, you pay for model access
Security owner	Anthropic	Anthropic	You

Two of these three are the same product wearing different clothes. Anthropic's help centre says Cowork "uses the same agentic architecture that powers Claude Code, with no terminal required". Both sit inside a paid Claude plan. Cowork is the younger surface: it is in beta on web and mobile for Max, Team and Enterprise, still rolling out to Pro, chat memory does not carry into Cowork sessions, and some features stay desktop-only.

OpenClaw is the only one you host

OpenClaw calls itself "a personal AI assistant that runs on your devices and meets you in the channels you already use", built for a single operator around one local Gateway. It is MIT-licensed under a non-profit foundation, runs on macOS, Linux, Windows and WSL2, and works with hosted or local model providers. Claude Code ships under a proprietary all-rights-reserved licence, so that independence is the real trade.

The channels gap is narrowing

OpenClaw's headline was meeting you where you already talk: WhatsApp, Telegram, Slack, Discord, Google Chat, Signal and iMessage. Claude Code now has Channels, a research preview covering Telegram, Discord and iMessage, where events "only arrive while the session is open". Narrower reach, pointed at coding work, and not always-on. The gap is smaller, not gone.

Self-hosting moves the security bill to you

OpenClaw's own documentation is blunt about this, which I respect. Tools "run on the host for the main session unless you configure sandboxing", and OpenClaw "is not a hostile multi-tenant security boundary for multiple adversarial users sharing one agent or gateway". The secure baseline is loopback binding with token auth, and the guidance is to never expose the Gateway unauthenticated on 0.0.0.0. There is an openclaw security audit command because you need one.

How to pick

Pay for a Claude plan and the Cowork question answers itself by task: repository work in Claude Code, everything else in Cowork. Choose OpenClaw when owning the host and the model matters more than the setup cost, and read the safer-agent comparison first. Still picking a coding agent? Start with Codex vs Claude Code vs GitHub Copilot, or OpenCode vs Claude Code vs Codex.

References

Claude Help Center. "Get started with Claude Cowork"
GitHub. openclaw/openclaw README
OpenClaw documentation. "Gateway security"
Claude Code documentation. "Channels"

Understanding Personalization Factors - Part 1: What Data Actually Matters vs. Noise

Alden Menzalji — Sun, 09 Aug 2026 09:17:01 +0000

Your analytics platform tracks 47 user attributes. Your marketing team has 23 audience segments. And somehow, your personalization still feels like throwing darts blindfolded.

Welcome to the personalization data paradox: drowning in data but starving for insights.

Hero photo by Luke Chesser on Unsplash

The Personalization Reality Check Series

Introduction to Personalization

Understanding Personalization Factors - Part 1: Data Taxonomy (You are here)

Understanding Personalization Factors - Part 2: CDPs & Strategy

Server-Side Personalization - Part 1: Architecture & Caching

Server-Side Personalization - Part 2: Performance & Decisions

Client-Side Personalization

Edge-Side Personalization

Choosing the Right Approach

Try the interactive version: the free Personalization Approach Picker turns this series into an 8-question assessment.

In our introduction, we covered why 53% of customers have negative experiences despite 92% of businesses investing in AI-driven strategies. Now let's explore the root cause: most companies collect the wrong data, organize it poorly, and act on noise instead of signal.

The Personalization Data Taxonomy

Before you can personalize effectively, understand the landscape of data available.

Historical/Behavioral Data

What it is: Past actions, purchases, and engagement patterns tracked over time.

Examples: Purchase history, content consumption, email engagement, search queries, cart abandonment, support tickets.

When it's useful:

Predicting product affinity from past purchases
Identifying lifecycle stage (new customer, repeat buyer, churner)
Segmenting by engagement level

When it's noise:

One-off purchases that don't indicate preference (gifts)
Data older than 12 months in fast-changing industries
Behavior during promotional periods that doesn't reflect normal patterns
Shared accounts or devices

Reality check: Behavioral data becomes less predictive over time. For many industries, data older than 6 months has minimal predictive value. Yet companies store years "just in case," creating bloat without insight.

Session-Based Data

What it is: Real-time information about the current browsing session.

Examples: Device type, browser/OS, referral source, geographic location (IP-based), time of visit, pages viewed, on-site search terms.

When it's useful:

Mobile-optimized experiences for mobile visitors
Location-based content (store locators, regional offers)
Referral-specific messaging
Session intent signals

When it's noise:

VPN/proxy locations that don't reflect true geography
Device data when responsive design already handles UX
Referrer data with unclear attribution
Timestamp without timezone context

The trap: Session data is ephemeral. Over-optimizing for session signals creates inconsistent experiences that confuse returning visitors.

Environmental/Contextual Data

What it is: External factors that influence user state and needs.

Examples: Weather conditions, local events, stock market conditions, sports scores, trending topics, seasonal factors.

When it's useful:

Weather-triggered product recommendations (umbrellas when raining)
Event-based promotions (local concerts, sports games)
Seasonal content relevance

When it's noise:

Weather data for products with no weather correlation
Events that don't align with your catalog
Trends that don't match your demographics

Case study: A major retailer spent 6 months integrating weather APIs. Result? 0.03% conversion lift because their electronics products had no weather correlation. They were solving a problem that didn't exist.

Demographic/Firmographic Data

What it is: Attributes about the person or company.

Examples: Age, gender, income (B2C); company size, industry, revenue, job title (B2B).

When it's useful:

B2B segmentation by company size (SMB vs. Enterprise messaging)
Age-appropriate content and recommendations
Income-based pricing tiers

When it's noise:

Inferred demographics from third-party data (often 30-40% inaccurate)
Self-reported demographics users falsify for privacy
Assumptions that reinforce stereotypes
Over-segmentation fragmenting audiences into unusably small groups

The problem: GDPR and CCPA restrict demographic collection. Third-party cookies are dying. The demographic data you relied on is disappearing, and what remains is increasingly inaccurate.

Psychographic/Intent Data

What it is: Attitudes, interests, motivations, and purchase intent signals.

Examples: Stated preferences, quiz responses, content topic engagement, brand affinity, purchase intent keywords.

When it's useful:

Content personalization based on stated interests
Nurture streams aligned with user goals
Intent-based sales prioritization

When it's noise:

Interests stated years ago that no longer apply
Survey responses with selection bias
Inferred intent from ambiguous behavior
Third-party psychographic profiles

Reality: Psychographic data is the hardest to collect accurately and easiest to misinterpret. Most companies use inferred psychographics (guessing from behavior) rather than stated preferences, leading to mismatches.

First-Party vs. Third-Party Data Reality in 2025

The Third-Party Cookie Apocalypse (Sort Of)

What vendors tell you: "Third-party cookies are dead! Adapt now or perish!"

What's actually happening:

Google restricted third-party cookies for 1% of Chrome users in January 2024
In July 2024, Google reversed the full phaseout after advertiser pushback
In April 2025, Google dropped the planned standalone consent prompt too; third-party cookies stay in Chrome indefinitely
Safari and Firefox already block third-party cookies by default

What this means:

Third-party cookies aren't fully dead, but mortally wounded
Privacy regulations restrict usage even where cookies work
Consent requirements leave analytics blind to a meaningful share of transactions
First-party data is the future

First-Party Data: The New Gold Standard

What it is: Data you collect directly from customers with their consent.

Examples: Email addresses (with permission), account preferences, purchase transactions, onsite behavior, survey responses, customer service interactions.

Why it matters:

89% of marketers now rely primarily on first-party data
More accurate (you control collection)
Privacy-compliant with consent
Builds direct relationships

The catch: First-party data requires giving customers reasons to share:

Value exchange (discounts, exclusive content, better experiences)
Trust (transparent usage, easy opt-out)
Utility (data improves their experience)

When it fails: Companies treating first-party collection like surveillance ("create account to continue") see 60-80% abandonment rates. Data sharing must feel like choice, not barrier.

Zero-Party Data: The Overlooked Opportunity

What it is: Data customers intentionally and proactively share.

Examples: Quiz responses ("What's your skin type?"), preference centers, product configurators, communication preferences, stated goals.

Why it's powerful:

83% of consumers willing to share data for personalized experiences
No inference error (they told you directly)
Creates engagement and value exchange
Explicitly privacy-friendly

The opportunity: Most companies ignore zero-party collection, relying on inferred preferences instead of asking directly. Customers will tell you what they want, if you ask respectfully and deliver value.

Signal vs. Noise: The 80/20 Rule

Data That Moves the Needle

First-party behavioral data (last 90 days):

Recent purchases and browsing
Category affinity
Price sensitivity signals
Channel preference

Zero-party stated preferences:

Communication frequency
Content interests
Product preferences
Stated goals

Session intent signals:

Current page type
Referral source context
On-site search queries
Cart contents and value

Lifecycle stage:

New visitor vs. returning customer
Active vs. at-risk vs. dormant
Customer value tier (based on actual spend)

Data That's Usually Noise

Weather (unless clear product correlation)
Inferred demographics (error-prone)
Historical data >12 months old
Third-party enrichment (low accuracy)
Psychographic profiles (guesswork)
Hundreds of behavioral micro-signals

The 80/20 rule: You'll get 80% of personalization value from 20% of available data. The challenge is identifying which 20%.

The Bottom Line

Most personalization failures stem from collecting wrong data, organizing poorly, and acting on noise. Before investing in technology:

What are our 4-6 core segments?
What data is accurate, complete, and current?
What decisions will personalization inform?
Will customers see value in sharing data?

Answer those first. Then build.

In Part 2, we'll cover CDP reality checks, data quality issues, the over-segmentation trap, and privacy-first strategy.

References

HubSpot (2024). "The Death of Third-Party Cookies"

Done Means Six Different Things on Your Build

Alden Menzalji — Sat, 08 Aug 2026 09:16:41 +0000

The button four people called done

You asked for a button that emails shoppers when a sold-out product is back. You ask if it is done. Design says done, they drew it. Dev says done, they merged it. QA has not opened it yet. It is not on the live site. Four people said "done" and not one customer has been emailed.

"Done" is a relay, not a finish line

Each stage on your build has its own finish line, and that line is the entry ticket for the next stage. When one stage calls something done that the next stage cannot use, the work bounces back and your calendar slips. A shared definition of done is just the checklist each stage passes before it hands off the baton.

Deciding how to get it built? The free Vibe Code or Hire a Developer assessment scores your project in 8 questions and tells you whether to vibe code it, use a site builder, hire, or split the work.

Discovery is done when the "then" is written

Not "we talked about it on a call." Done here means the who, the when, and the then are written down, and the "then" is an outcome you can watch happen. If nobody can point at a sentence and check it later, discovery is not finished, no matter how good the meeting felt.

Design is done when every state is drawn

Not just the pretty hero shot. Done means the empty state, the loading state, the error state, and the mobile view are all drawn, plus the edge cases from your story. A design that only shows the happy path hands dev a guess for every screen a real customer will actually hit.

Dev is done when it matches the story, not just when it merges

"It is merged" is not done. Done means it was built to the story, it matches the design, and it works on the exact browsers and screens the story named. The edge-case lines you wrote are handled, not skipped. Merged code that nobody checked against your "then" is just a guess with a green checkmark.

QA is done when every "then" passes

Not "it opened without crashing." Done means every "then" line and every edge case has been checked and passes on the screens the story named. Anything that fails gets written up with your bug template so it is fixed, not forgotten. QA is where the sentences you wrote meet reality.

Prod is done when it is live and reversible

Staging is not done. Done means the feature is on the real site, the analytics are firing, and someone knows how to roll it back if it misbehaves at 2am. A feature that works everywhere except the place your customers stand is not finished, it is rehearsing.

You are done when you watch your own "then" happen

The last checkpoint is yours. Done for you is not "looks good." It is opening the live URL, doing the thing, and watching the exact "then" you wrote back in discovery happen with your own eyes. That single sentence has traveled the whole chain, and you are the one who confirms it landed.

The whole thing in one line

Write the "then" once, and make every stage prove it before handing off. Six people, one sentence, checked against reality until the last person checking it is you.

References

Scrum.org. "The Scrum Guide: Definition of Done"
Atlassian. "What is the Definition of Done (DoD) in Agile?"

OpenCode vs Claude Code vs Codex: Which Should You Use in 2026?

Alden Menzalji — Fri, 07 Aug 2026 09:23:04 +0000

Short answer: OpenCode if you want to change models without changing agents, Codex if you already pay OpenAI, Claude Code if you want Anthropic's own tool

Verified August 7, 2026. TL;DR: OpenCode is MIT-licensed, reaches 75+ providers out of the box, and signs in to a ChatGPT Plus, GitHub Copilot or GitLab Duo seat you already pay for. Codex is bundled into every ChatGPT plan, including the $0 one. Claude Code has no free tier and runs Claude models only. Pick by which subscription you already hold.

	OpenCode	Claude Code	Codex
Made by	Anomaly	Anthropic	OpenAI
Models	75+ providers plus local, built in	Claude only	OpenAI, plus providers you configure
Cheapest start	$0, bring your own API key	Paid Claude plan or Console credits	$0 on ChatGPT Free
Subscriptions it accepts	ChatGPT Plus, Copilot, GitLab Duo	Any paid Claude plan	Every ChatGPT plan, Free up
First-party billing	Go $10/mo, or Zen per request	Included in your Claude plan	Included in your ChatGPT plan
Client licence	MIT	None published	Apache 2.0

The subscription you already pay for may not travel

OpenCode's docs list ChatGPT Plus, GitHub Copilot and GitLab Duo as subscriptions that work "with zero setup". Claude is the exception, and OpenCode says so plainly: Anthropic "explicitly prohibits" using Pro or Max models this way, and the plugins that once did it were dropped in version 1.3.0. So an OpenAI seat drives two of these three agents. A Claude seat drives one.

Codex is less locked to OpenAI than it looks

Codex's CLI is Apache 2.0 with about 105,000 GitHub stars, and its user-level config accepts a model_providers block, with worked examples for Ollama, Mistral and an LLM proxy. OpenCode is MIT with about 194,000 stars and ships a provider list 75+ long, so the same job needs less config. Anthropic's claude-code repo publishes no open source licence. The gap is convenience, not capability.

The cheapest way in is different for each

Codex is listed at $0 on ChatGPT Free, then $8 on Go and $20 on Plus. OpenCode costs nothing to install and nothing extra to run against a provider key you already have, or $10 a month (first month $5) on OpenCode Go for open models. Claude Code is the outlier: it is included in all paid Claude plans, and there is no free tier.

Three different meters

Claude Code shares one pool with Claude on web, desktop and mobile, resetting on a rolling five-hour window with weekly limits on top. Codex meters five-hour windows too, with weekly limits OpenAI says may apply. OpenCode Go meters dollars: $12 per five hours, $30 a week, $60 a month. Point OpenCode at your own key instead and nobody meters you but your provider.

How to choose, in one line each

Already paying for ChatGPT, start with Codex and pay nothing extra. Want an agent that outlives a vendor switch, or local models behind your own gateway, install OpenCode. Want Claude models, buy a Claude plan and run Claude Code: OpenCode's docs say Anthropic prohibits driving a Pro or Max seat from outside. Wider field: Codex vs Cursor vs Claude Code, Gemini CLI vs Claude Code vs Codex, and the Codex, Claude Code and Copilot breakdown.

References

How to File a Bug Report Your Agency Will Act On Right Away

Alden Menzalji — Thu, 06 Aug 2026 09:58:29 +0000

Have you ever reported a bug to your implementation agency and watched it turn into a week of email? You send a quick note that something is broken. A day later they reply, not with a fix, but with a question: which browser? Can you send a screenshot? What were you doing when it happened? Every reply costs you another day, and the thing is still broken.

If you are a founder or a non-technical owner paying an agency to build and run your site, this one is for you. There are two reasons you get the runaround. Only one of them is your fault, and both get shorter when you file the bug the right way.

Deciding how to get it built? The free Vibe Code or Hire a Developer assessment scores your project in 8 questions and tells you whether to vibe code it, use a site builder, hire, or split the work.

The stall you cannot control

Most agencies work to a response-time commitment, something like "we reply within one business day." When a team is slammed, that number quietly stops being a promise and becomes a countdown. A low-effort first reply ("Can you send the logs?" or "Which browser was this on?") resets the clock and buys them time before anyone has to actually look at your problem.

You cannot fully control whether an agency plays that game. What you can control is leaving them nothing trivial to ask. If your very first message already answers every obvious question, the fastest path for them is to stop stalling and fix the bug.

The details only you can give them

The second reason is legitimate. A report that just says "the checkout is broken" genuinely cannot be worked on. Before anyone can reproduce the problem, they need to know a few things that only you can see:

On a web app, was it on desktop, tablet, or mobile?
Which browser: Chrome, Edge, Firefox, Safari?
Which page, exactly?
What did you do right before it broke?
What did you see, and what did you expect to see instead?

Every one of those unknowns is a separate round-trip email. Five unknowns can turn a ten-minute fix into a week of back-and-forth. Answer them all up front and you collapse that week into a single ticket.

The template that ends the back-and-forth

Most agencies will hand you a bug template, or you can build one together. If they do not have one, use this. It works for any web-based site or app. Copy it, fill it in, send it.

Title: describe the bug in under 10 words
Page URL: the exact address where it happens
Browser: Chrome, Edge, Firefox, Safari, and so on
Screen: desktop, tablet, or mobile
Steps to reproduce: number them, exactly what you did
What I see now: what actually happens
What I expected: what should have happened instead
Screenshot or screen recording: attach one if you can

That last line is the one that changes everything. A ten-second screen recording of the bug happening, or even a single screenshot with the broken part visible, often tells a developer more than three paragraphs of description ever could. Every phone and computer can record its own screen now. If you can capture the bug in the act, always attach it.

None of this is just my preference. It is the same core information Atlassian and Microsoft tell their own engineering teams to capture in a bug report.

What a good one looks like

Here is the template filled in. Notice there is nothing left to ask. Someone can read this, open that page on a phone in Chrome, and see the problem in under a minute.

File it like this and you skip both the stall and the twenty questions. Your agency gets everything it needs in one message, and you get your fix in one reply instead of ten.

References

Atlassian. "Bug report template"
Microsoft Learn. "Define, capture, triage, and manage bugs in Azure Boards"

Tell Your Agency What You Want, Not How to Build It

Alden Menzalji — Tue, 04 Aug 2026 09:55:58 +0000

The protein tortilla test

Send someone to buy high-protein tortillas. You say "high protein, around 10 grams each is great." That is the going rate, and most land right about there on the shelf. They grab a pack, done. Off the shelf, ready to use, no drama.

Now demand exactly 11.8 grams

Watch what happens. They shrug, decide 11.8 was not a real requirement, and hand you the standard pack anyway. Maybe that is fine. Maybe it quietly was not. Or they take you literally, and since no shelf tortilla hits that number, they build a factory for yours and send you the bill.

Your specs work the same way

"Users can reset their password from their phone" is the around-10-grams request, the off-the-shelf kind any developer fills. "Build it as a React hook calling this exact endpoint, storing the token this way" is the 11.8-gram version: a constraint nobody needed, or a custom factory for something already on the shelf.

Deciding how to get it built? The free Vibe Code or Hire a Developer assessment scores your project in 8 questions and tells you whether to vibe code it, use a site builder, hire, or split the work.

You can build almost anything now

If you cannot code, AI just handed you a superpower. You can spec a whole product over a weekend. That is genuinely great, and it opened a fresh trap: it has never been easier to walk into your agency with a full set of build instructions.

The trap is precision aimed at the wrong thing

These days clients show up with the whole recipe: "I want this, here is exactly how to build it, use this library, structure it this way." The instinct is good. But precision aimed at the how, instead of the what, quietly makes your project slower, pricier, and more fragile.

What this post is about

Working with an agency can feel like ordering food in a language you do not speak. You know what you want on the plate, you are just not sure how to ask. This series closes that gap. Another post covers filing a bug your agency acts on fast. This one is about how much of the how to keep.

Hand over the recipe and one of two things happens

When your how-to instructions hit a developer's desk, neither outcome is good. They either follow every line to the letter, or quietly decide which lines to ignore. Both cost you.

They follow every line

Every "do it this way" becomes a hard constraint, including the ones you never cared about and only added because you read they were best practice. Developers cannot tell your must-haves from your maybes, so all of it hardens into requirements. The work slows and tangles.

Or they quietly ignore it

They drop the parts that look optional and build what they think you meant. Sometimes that lands. Often it does not, and you find out while staring at something wrong, with no clean way to point at where it went sideways.

The fix: say what, not how

Tell your agency what you want to achieve. The functionality. The behavior. What should happen when a user taps the button. Then leave the how to them. Choosing the library, the pattern, and the structure is exactly what a good partner does for a living.

Trust is the whole point

If you trust them enough to build your product, trust them to make those calls. If you do not trust them that far, the problem is not your spec. It is your partner.

The one time to say how: consistency

There is a real exception. If the new thing has to live next to systems you already own, and those were built a certain way, say so. That is the how instruction that earns its place, because it keeps your whole platform coherent.

The ten-website rule

You already run ten sites, all in PHP, and you are adding an eleventh. Now it is smart to ask for PHP too. Not because PHP is better, but because the day you hire someone to maintain it all, you want PHP developers, not a zoo of specialists for eleven stacks.

No stack preference? Do not invent one

Pick an agency you trust and let them build in what they do best. For most small and mid-size sites, it honestly does not matter much. Nearly every modern stack does what the others do, and the differences engineers argue about online rarely show up in your product.

Strong preference? Take it to the right shop

If you really want .NET or Java, that is fine, but act on it at the right moment: hire an agency known for that stack. Want everything in .NET? Find a .NET shop. Set on Java? Find a Java shop.

There is no single best stack

The giants disagree. Facebook was built on PHP. Microsoft built its ecosystem on .NET. Netflix runs its massive backend on Java. If one stack were truly best, the others would have died out. There is no best, only trade-offs, and a good partner picks the fit.

Never send a .NET shop to build Java

Nobody says no to money. Ask a .NET shop for a Java app and they will not turn you away. They smile, sign the contract, then subcontract to a stranger or scramble to hire Java developers they did not have yesterday.

That is a seat you never want

Now you are paying a shop out of its depth to manage people it just met, on its least confident ground. That is exactly the spot to avoid. If you care about the stack, hire for the stack.

The whole series in one line

Be crystal clear about the what. Be generous about the how.

References

Wikipedia. "HipHop for PHP"
Microsoft Learn. ".NET Managed languages strategy"
InfoQ. "How Netflix Really Uses Java"

Codex vs Cursor vs Claude Code: Which Should You Use in 2026?

Alden Menzalji — Mon, 03 Aug 2026 10:19:05 +0000

Short answer: Codex if you already pay OpenAI, Cursor if you want all three vendors' models, Claude Code if you live in the terminal

Verified August 3, 2026. TL;DR: Codex is bundled into every ChatGPT plan, including the $0 one, so it costs nothing extra if you already pay OpenAI. Cursor is the only one of the three that runs OpenAI, Anthropic and Google models in the same editor. Claude Code has no free tier and is the terminal-first option. Pick by what you already pay for.

	Codex	Cursor	Claude Code
Form	Web, CLI, IDE extension, iOS	IDE, CLI, iOS, cloud agents	Terminal, IDE, desktop, web
Free tier	ChatGPT Free, $0	Hobby, $0	None
Entry paid tier	Go $8, Plus $20	Pro, $20/mo	Pro, $20/mo, $17 annual
Top individual tier	Pro, from $100, 5x or 20x Plus	Ultra, $200, 20x Pro limits	Max, from $100
Models	OpenAI only	OpenAI, Anthropic, Google, SpaceXAI, Composer	Claude only
What it meters	Five-hour window, weekly may apply	Dollars of model usage	Five-hour window plus weekly

Cursor is the only one that runs the other two's models

Cursor's model list carries GPT-5.6 Sol, Terra and Luna next to Claude Opus 5, Sonnet 5 and Fable 5, plus Gemini and Cursor's own Composer 2.5 and Grok 4.5. Codex runs OpenAI models, and on an API key availability just follows your key. Claude Code runs Claude models. This is not three equivalent products: it is two vendor agents and one neutral editor that hosts both.

Two of them meter time, one meters dollars

Codex and Claude Code bill in windows. OpenAI's Plus limits are 10 to 100 GPT-5.6 Sol messages per five hours, 25 to 200 on Terra and 250 to 2,000 on Luna, with additional weekly limits that may apply. Claude's allowance resets on a rolling five-hour window plus a weekly one, shared with Claude chat and Cowork. Cursor bills dollars: Pro includes $20 of third-party model usage a month, then usage continues at API rates.

The free tiers are not comparable

Codex is listed at $0 on ChatGPT Free, then $8 on Go and $20 on Plus. Cursor's Hobby plan is $0 too. Claude Code has no free tier: Anthropic's pricing FAQ says it is "included in all paid plans", which starts at Pro, $20 monthly or $17 billed annually. If you want to test a coding agent without handing over a card, that rules Claude Code out and leaves two.

Budget the top tier, not the entry tier

Sticker prices understate what a working seat costs. Anthropic's own cost guidance puts enterprise Claude Code at roughly $13 per developer per active day and $150 to $250 per developer per month, staying under $30 per active day for 90% of users. Cursor's Ultra tier is $200 a month and Codex Pro starts at $100. Plan for the tier above the one you think you need.

How to choose, in one line each

Already paying for ChatGPT, start with Codex, because it costs nothing extra. Want one editor that runs all three vendors' models, buy Cursor and read Claude Code vs Cursor first. Want a terminal-first agent tied to Claude models, buy Claude Pro. For the wider field, see the Codex, Claude Code and Copilot breakdown, Gemini CLI vs Claude Code vs Codex, or Antigravity vs Cursor vs Claude Code.

References

Describe What You Want, One Component at a Time

Alden Menzalji — Sun, 02 Aug 2026 09:41:53 +0000

Start with the services grid

Say you run an immigration agency. Your homepage has a Services section: a tidy grid of cards. Visitor Visa. Study Permit. Citizenship Application. Five of them, lined up. You feel like you owe your agency a document describing all five, a spec covering every color, feature, and half-formed wish. You do not. Every card is the same shape wearing different words.

Deciding how to get it built? The free Vibe Code or Hire a Developer assessment scores your project in 8 questions and tells you whether to vibe code it, use a site builder, hire, or split the work.

Your site is a box of repeating parts

Here is the reframe. A website is not one giant thing to describe. It is a set of components: a hero, a form, a pricing table, that services grid. Each is separable, and the good news is they repeat. Those five service cards are one component wearing five outfits. So you do not spec five cards. You spec the shape of a card, once.

Give every component a one-pager

Once you can see the parts, describe each one on a single page. Not a spec, a brief: a few short sections your agency can read in two minutes and turn into backlog items you control. Here is the whole page, written out for the service card. Steal the shape for every component you own.

The gist. A grid of cards on the homepage, one per service. Each card sells one service at a glance and takes the visitor to that service's page.
Where it lives, and who does what.
- On the public site: the services grid on the homepage.
- In the admin: a screen where you add, edit, hide, and reorder cards yourself, no developer needed.
- The agency builds both sides. You write the words.
What goes on a card.

| On the card | What it is |
| --- | --- |
| Title | Short text, the name people click |
| Selling line | Short text, one sentence that sells it |
| Photo | An image |
| Brand color | A color, as a hex like #0E7C86 |
| Price | Short text, "From $1,200" or "Contact us" |
| Link | The page the card opens |

When a card earns its spot.
- No title, no card. A card without a name has lost its meaning, so hide it.
- Missing the photo? Fill that space with the brand color.
- A card with no destination yet can stay visible, it just goes nowhere.
- And if every card is hidden, the homepage skips the grid entirely.
How it should feel.
- Tapping anywhere on the card, photo or text, opens the service page.
- A slight lift and shadow on hover, enough to invite the click, nothing theatrical.
Room to grow. Flag what might change someday: a sixth service will arrive eventually, and the photo could become a short looping clip. One heads-up line each, not a requirement.
How many fit a row.

| Screen | Cards in a row |
| --- | --- |
| Phone | 1 |
| Tablet | 2 |
| Desktop | 3 |

The picture. Staple on a napkin sketch, a screenshot of a site that got it right, anything visual. More on that below.
What the page leaves out. Anything about how to build it: no frameworks, no animation libraries, no pixel measurements. The how is your agency's half of the deal.

Fill in exactly one, completely

So do it for real, once. Card: Citizenship Application. Sells it: "Become a citizen with confidence." Photo of a passport. Color #0E7C86. Price: From $1,200. Clicking it lands on /services/citizenship-application. The hero image below shows that one card, fully filled in, so you can hand it over instead of describing it in prose. The other four are this card with different words.

Then hand over a picture

Words drift; pictures do not. Grab a napkin, sketch where the photo sits, where the title goes, where the price lands. Photograph it with your phone. A crooked hand-drawn box beats three careful paragraphs about spacing, and it takes ninety seconds. If a card later shows up wrong, that same instinct powers a clean bug report your agency will act on.

The whole move in one line

Break the site into repeating parts, give each part a one-pager, fill in one example completely, and photograph a rough sketch of the rest. You are not writing a spec, you are handing over an example clear enough to copy. Do that per component and the overwhelm evaporates, one card at a time. It is the same move that runs through this whole series: show, do not tell.

Antigravity vs Cursor vs Claude Code: Which Should You Use in 2026?

Alden Menzalji — Fri, 31 Jul 2026 09:56:56 +0000

Short answer: Antigravity is free and runs Claude Opus, Cursor is the more mature editor

Verified July 31, 2026. TL;DR: Google Antigravity is $0 a month for individuals, and its model table gives that free plan Claude Opus 4.6 alongside Gemini. Cursor's paid tier starts at $20 and Claude Code has no free tier at all. If budget is the constraint, start on Antigravity. If you want the mature editor, pay Cursor. If you want a terminal agent, buy Claude Pro.

	Google Antigravity	Cursor	Claude Code
Form	IDE, standalone agent app, CLI, and SDK	Full IDE	Terminal agent
Free tier	$0/mo, basic weekly rate limits	Hobby, $0	None
Entry paid tier	Google AI Pro, $20/mo	Pro, $20/mo	Claude Pro, $20/mo, $17 annual
Top individual tier	AI Ultra, $200/mo, 20X Pro tokens	Ultra, $200/mo, 20x Pro limits	Max, from $100/mo, 5x or 20x Pro
What it meters	Weekly quota free, five-hour refresh plus weekly cap paid	Agent limits per tier	Rolling five-hour window plus weekly

The free tiers are not the same free tier

Antigravity's pricing page lists "For Individuals" at "$0/month" with "Unlimited Tab completions" and "Basic weekly rate limits", and its model table checks Claude Sonnet 4.6, Claude Opus 4.6 and GPT-OSS-120b for the free plan. Read the caveat: Google's plans page files "Access to third-party models" under Ultra, and its May 19 post says non-Gemini models "remain on a separate fixed rate limit". Cursor's Hobby plan is $0 too. Claude Code has none.

The paid ladders have converged

On May 19, 2026 Google cut its top Antigravity tier "from $250 to $200" and added a $100 Ultra with "a rate limit of 5X worth of tokens compared to the $20/mo Pro plan". Cursor runs Pro at $20, Pro+ at $60 with "3x Pro limits on Agent", Ultra at $200 with "20x Pro limits on Agent". Claude Pro is $20, $17 annually, Max from $100 with "5x or 20x more usage than Pro".

Antigravity is four products, not one

Antigravity is four things: Antigravity 2.0, "a standalone desktop application" that "functions independently of an IDE", plus the CLI, the IDE and an SDK. The IDE's agent actuates Chrome for "dashboard reads, SCM actions, UI testing". Cursor ships native browser control too; Claude Code gets there through an MCP server or the separate Claude for Chrome extension. Google's own caveat: "Antigravity IDE is not supported for enterprise customers."

How to choose, in one line each

If you are spending nothing, install Antigravity and run Opus on Google's bill. If you want the mature editor with a published limit ladder, pay Cursor, and read Claude Code vs Cursor and Cursor vs Copilot. If you want an agent you point at a repo, buy Claude Pro, then compare the wider field in the Codex, Claude Code, and Copilot breakdown or Windsurf vs Cursor vs Claude Code.

References

Windsurf vs Cursor vs Claude Code: Which Should You Use in 2026?

Alden Menzalji — Wed, 29 Jul 2026 09:55:36 +0000

Short answer: Windsurf is now Devin Desktop, so you are choosing between two IDEs and one terminal agent

Verified July 29, 2026. TL;DR: Windsurf was renamed Devin Desktop on June 2, 2026, and windsurf.com now redirects to devin.ai. It is the same editor at the same price. Cursor is the other full IDE. Claude Code is not an editor at all, it is an agent that runs in your terminal, and it is the only one of the three with no free tier.

	Devin Desktop (was Windsurf)	Cursor	Claude Code
Form	Full IDE, renamed June 2, 2026	Full IDE	Terminal agent
Free tier	Free plan, $0	Hobby, free	None
Entry paid tier	Pro $20/mo	Pro $20/mo	Claude Pro $20/mo, $17 annual
Top individual tier	Max $200/mo	Ultra, 20x Pro agent limits	Claude Max, from $100/mo
What it meters	Quotas refreshing daily and weekly	Agent limits per tier	Rolling five-hour session window plus weekly

Windsurf did not die, it was renamed

Cognition shipped the rename as a regular over-the-air update on June 2, 2026. The FAQ is blunt: "It's the same IDE, same editor, and has the same features, but unified under the Devin brand," and "Your current plan continues to work exactly as it does today. Pricing is unchanged." What did change is the built-in agent. Cascade was replaced by Devin Local, which Cognition says is up to 30% more token efficient and supports subagents.

Cursor and Devin sell headroom, not different products

Both ladders are the same editor with more allowance. Cursor runs Hobby free, Pro at $20, Pro Plus at "3x Pro limits on Agent", Ultra at "20x Pro limits", and Teams from $40 per user. Devin runs Free, Pro at $20, Max at $200, and Teams at $80 a month plus $40 per developer seat. At the entry price the two are a coin flip, so pick on feel, not on the price page.

Claude Code is not competing on the same axis

Claude Code has no free tier. It comes with Claude Pro at $20 a month, $17 billed annually, or Claude Max from $100, and Anthropic's limits "reset on a rolling five-hour session window, and paid plans add weekly limits on top". It also has no editor: you point it at a repo from the terminal, which is why Claude Code vs Cursor is the more useful matchup.

The three-way question is turning into two questions

Devin Desktop ships the Agent Client Protocol, which Cognition describes as "an open-source protocol that lets any compatible agent run inside any ACP-compatible editor", naming Codex, Claude Agent and OpenCode at launch. The editor that used to be Windsurf now hosts rival agents by design, and its front door is a command center for local and cloud agents. Choosing an editor and choosing an agent are separating into two decisions.

How to choose, in one line each

Want an IDE that treats agents as a fleet you manage, install Devin Desktop. Want the other IDE with a published limit ladder, pay Cursor. Want an agent you point at a repo, use Claude Code, or compare the terminal field in Gemini CLI vs Claude Code vs Codex and the Codex, Claude Code, and Copilot breakdown. If the question is whether to write the code at all, run the vibe code or hire check.