DEV Community: Alden Menzalji

AI Trends 2025 - The Enterprise Reality Check Nobody's Talking About

Alden Menzalji — Fri, 18 Sep 2026 12:26:25 +0000

Your CEO just forwarded you another breathless article about AI replacing your entire team. Your inbox is flooded with vendors promising "10x productivity" with their new AI assistant. Your board wants to know your "AI strategy."

Welcome to 2025, where everyone's talking about AI but very few are actually making it work in production.

Hero photo by Google DeepMind on Unsplash

Let's cut through the noise and talk about what's actually happening in enterprise AI: the unglamorous reality behind the hype, the trends that matter, and the hard truths vendors won't tell you.

The State of AI in 2025: A Reality Check

Here's where we actually are:

What's Real

Generative AI has crossed the threshold - GPT-4, Claude, Gemini, and other large language models (LLMs) are genuinely useful tools that can write code, analyze documents, draft content, and assist with complex reasoning tasks.

Code generation works - GitHub Copilot, Cursor, and similar tools are legitimately improving developer productivity for certain tasks. Not 10x, but real measurable gains of 20-40% for specific workflows.

Document processing is transformative - AI-powered document understanding (OCR, extraction, classification) is finally good enough to replace manual data entry at scale.

Search is being reinvented - Retrieval-Augmented Generation (RAG) is making enterprise search actually useful for the first time in decades.

What's Hype

"AI will replace developers" - No. AI will augment developers who know how to use it and leave behind those who don't. The skill gap is widening, not closing.

"Deploy GPT and save millions" - Most "AI ROI" calculations ignore the infrastructure costs, data preparation work, ongoing fine-tuning, and organizational change management required.

"One model to rule them all" - Different use cases require different approaches. RAG for knowledge work, fine-tuned models for specialized domains, traditional ML for predictive tasks.

"Just plug and play" - Production AI requires data pipelines, monitoring, quality assurance, human-in-the-loop workflows, and continuous iteration. It's never plug-and-play.

The Real AI Trends That Matter in 2025

Let's talk about what's actually moving the needle in production environments.

1. RAG Architecture Is Becoming Enterprise Standard

What it is: Retrieval-Augmented Generation combines your company's proprietary data with LLM reasoning. Instead of fine-tuning expensive models, you retrieve relevant context from your documents and feed it to the model.

Why it matters:

Works with off-the-shelf models (no expensive training)
Keeps data current (updates reflect immediately)
Provides citations and traceability (critical for enterprise compliance)
Dramatically reduces hallucination rates

The reality:

RAG isn't magic: garbage data in, garbage answers out
Vector database selection matters more than most realize
Chunking strategies can make or break your results
You need robust document preprocessing pipelines

What's working:

Customer support knowledge bases (80% answer accuracy with proper setup)
Internal policy and procedure retrieval
Technical documentation Q&A
Contract analysis and review

2. The Death of the "AI Strategy" Document

Here's an unpopular truth: if you have a separate "AI strategy," you're already behind.

The shift: AI is becoming infrastructure, not strategy. You don't have a "cloud strategy" or a "database strategy." You have business strategies that use these technologies.

What successful companies are doing:

Embedding AI capabilities into existing product roadmaps
Building AI competency centers (not innovation labs)
Treating AI as a capability, not a project
Focusing on specific use cases with measurable ROI

The anti-pattern:

Creating "AI departments" disconnected from business units
Pursuing AI for AI's sake
Innovation theater (demos that never reach production)
Waiting for the "perfect" solution instead of iterating

3. Small, Specialized Models Are Outperforming Large General Models

The pendulum is swinging back from "bigger is better."

The trend: Task-specific smaller models (7B-13B parameters) fine-tuned on domain data are outperforming GPT-4 on specific enterprise tasks, at a fraction of the cost.

Why it matters:

10-100x lower inference costs
Better performance on specialized tasks
Faster response times
Can run on-premises (data sovereignty, compliance)
More predictable behavior

Real-world examples:

Code completion models trained on your codebase
Industry-specific document extraction
Compliance classification for regulated industries
Customer support intent classification

The catch:

Requires ML expertise to fine-tune properly
Need quality training data
More complex to maintain (model versioning, A/B testing)
Still need foundation models for general reasoning

4. AI Governance Is Moving from Checkbox to Competitive Advantage

The companies winning with AI aren't moving fast and breaking things. They're building robust governance from day one.

Why governance matters now:

EU AI Act enforcement is beginning
Insurance and legal liability issues are clarifying
Customers are demanding transparency
Model failures are increasingly public and costly

What good governance looks like:

Human-in-the-loop for high-stakes decisions
Model monitoring and performance tracking
Data lineage and explainability
Bias testing and mitigation
Clear escalation paths when AI fails

The competitive angle:

Privacy-first positioning attracts customers
Explainable AI reduces legal risk
Reliable AI builds customer trust
Governance enables faster experimentation (paradoxically)

5. Multimodal AI Is Moving Beyond Demos

Text-only AI was 2023. Multimodal (text + images + audio + video) is the 2025 reality.

What's working in production:

Visual quality inspection in manufacturing
Document processing (tables, charts, handwriting)
Video content moderation
Accessibility (alt text generation, captions)
Medical imaging analysis

Why multimodal matters:

Most enterprise data isn't text
Visual context dramatically improves accuracy
Enables new use cases that text-only couldn't handle

The reality check:

Still expensive to run at scale
Requires different infrastructure (GPUs, storage)
Quality varies wildly by use case
Privacy concerns are magnified (image data is sensitive)

6. The "AI Data Problem" Is Getting Worse Before It Gets Better

AI doesn't solve your data quality problems. It exposes them.

The hard truth:

If your data is messy, your AI will be unreliable
Most enterprises have 10-20 years of accumulated data debt
Data preparation is 80% of AI project time
"Just throw it in a vector database" doesn't work

What successful companies are doing:

Treating data quality as a prerequisite, not an afterthought
Building data catalogs and metadata systems
Implementing data governance before AI projects
Starting with high-quality data subsets, expanding gradually

The anti-pattern:

"AI will magically understand our messy data"
Skipping data preparation to meet deadlines
Assuming more data is always better
Ignoring data governance

What You Should Actually Be Doing in 2025

Enough trends. Let's talk tactics. Here's what's working:

Start with High-Value, Low-Risk Use Cases

Don't start with mission-critical systems. Start with:

Internal productivity tools:

Code documentation generation
Meeting summarization
Email drafting assistance
Internal knowledge search

Why these work:

Low risk if AI makes mistakes
Quick feedback loops
High user tolerance for imperfection
Clear ROI measurement

Then graduate to:

Customer-facing chatbots (with human escalation)
Document processing and data extraction
Predictive analytics and forecasting
Content generation with human review

Build the Boring Infrastructure First

The companies succeeding with AI aren't chasing the latest models. They're building:

Data foundations:

Clean, well-documented data sources
Vector databases and embedding strategies
Data pipelines for continuous updates
Quality monitoring and alerting

Evaluation frameworks:

Test sets for measuring model performance
A/B testing infrastructure
User feedback loops
Performance dashboards

Governance systems:

Model versioning and rollback capabilities
Human review workflows
Audit trails and explainability
Privacy and security controls

Treat AI as an Iterative Process, Not a Project

AI isn't software you deploy once. It's a continuous improvement cycle:

Start small - One use case, limited scope
Measure everything - Response quality, user satisfaction, business impact
Iterate based on real usage - Not assumptions
Scale gradually - Don't skip the learning phase
Plan for model refresh - Models drift, data changes, needs evolve

Invest in AI Literacy, Not Just AI Tools

The bottleneck isn't technology. It's people understanding how to use it effectively.

What works:

Hands-on training with real use cases
Internal champions and early adopters
"Office hours" for AI questions
Shared learnings and best practices

What doesn't:

Generic "AI 101" presentations
Vendor-led training (they sell, you buy)
One-time training events
Assuming "everyone knows AI now"

The Hard Truths Nobody Wants to Hear

Let's end with some uncomfortable realities:

1. Most AI Projects Will Fail

Not because AI doesn't work, but because:

Unclear success metrics
Poor data quality
Lack of organizational buy-in
Unrealistic expectations
Insufficient resources for iteration

The fix: Define success upfront, secure stakeholder buy-in, start small, measure relentlessly.

2. AI Won't Reduce Your Headcount

It will shift what people do. Your team will:

Focus on higher-value work
Review and refine AI outputs
Handle edge cases AI can't
Continuously improve AI systems

The companies cutting headcount to "AI efficiencies" are setting themselves up for quality disasters.

3. Your First Model Will Be Terrible

And that's okay. Every production AI system starts with a bad model that gets better through:

Real user feedback
Continuous evaluation
Data quality improvements
Iterative refinement

The companies succeeding aren't the ones with the best first attempt. They're the ones who iterate fastest.

4. ROI Takes Longer Than Vendors Claim

Vendor marketing: "See ROI in 30 days!"

Reality:

Months 1-3: Infrastructure setup, data preparation
Months 4-6: Initial deployment, learning, iteration
Months 7-12: Refinement based on real usage
Year 2+: Actual ROI as the system matures

Plan for a 12-18 month timeline from start to meaningful ROI.

5. You Don't Need Bleeding-Edge Models

GPT-4 and Claude are impressive, but:

GPT-3.5 is often sufficient (and 10x cheaper)
Fine-tuned smaller models outperform for specific tasks
Older, stable models mean fewer surprises in production

Use the simplest model that solves the problem. Over-engineering with the latest model creates unnecessary complexity and cost.

What's Coming Next

Looking ahead to 2026 and beyond:

Agentic AI - AI systems that can take multi-step actions autonomously (with human oversight) will move from research to production.

Embedded AI - AI capabilities baked into every application, not separate "AI tools."

Edge AI - More processing happening on-device (phones, IoT) as models get smaller and more efficient.

Regulation clarification - EU AI Act, state-level US regulations, and industry-specific rules will create clearer compliance requirements.

Commoditization - AI capabilities that were cutting-edge in 2024 become table stakes in 2025-2026.

The Bottom Line

AI in 2025 isn't about chasing the latest model or implementing chatbots because everyone else is. It's about:

Solving real business problems with measurable impact
Building robust infrastructure that enables continuous improvement
Treating AI as a capability, not a strategy
Investing in data quality as the foundation
Iterating based on real usage, not assumptions
Being realistic about timelines, costs, and limitations

The companies succeeding with AI aren't the ones with the most ambitious vision statements. They're the ones doing the boring infrastructure work, measuring everything, iterating quickly, and treating AI as a tool, not magic.

If your AI strategy can fit in a deck, it's probably theater. If it's embedded in your product roadmap, engineering processes, and operational workflows, you're on the right track.

The AI revolution is real. But it's happening in the data pipelines, RAG architectures, and continuous improvement processes, not in the marketing materials.

OpenCode vs Codex: Which Should You Use in 2026?

Alden Menzalji — Tue, 15 Sep 2026 12:55:10 +0000

Short answer: OpenCode if you want one agent across every provider, Codex if your models come from OpenAI

Verified September 12, 2026. TL;DR: OpenCode is MIT-licensed, reaches 75+ providers, and signs in to a ChatGPT Plus seat with zero setup, so one OpenAI subscription can drive both agents. Codex is Apache 2.0 and costs $0 inside ChatGPT Free. Both are open source, and only one is provider-neutral. Pick by whether you ever expect to leave OpenAI.

	OpenCode	Codex
Repo and licence	`anomalyco/opencode`, MIT	`openai/codex`, Apache 2.0
GitHub stars today	206,839	123,532
Models	75+ providers, plus local	OpenAI's own, on your ChatGPT plan
Cheapest start	$0, bring your own key	$0 on ChatGPT Free
First-party plan	OpenCode Go, $10 a month	Bundled in ChatGPT, $8 to $200

Which is cheaper, OpenCode or Codex?

Codex at the very bottom, OpenCode everywhere above it. Codex is $0 on ChatGPT Free, $8 on Go and $20 on Plus, but it is never sold alone: the price is a ChatGPT plan. OpenCode's client costs nothing and adds nothing to a provider key you already hold. With no key and no subscription, Codex is the cheaper first hour.

Can you run Codex inside OpenCode?

Not the agent, but its models, yes. OpenCode's /connect command signs in to a ChatGPT Plus or Pro subscription with zero setup, alongside GitHub Copilot and GitLab Duo seats. Your OpenAI models then run inside OpenCode while Codex stays a separate program. Anthropic is the exception OpenCode names in its docs: driving a Claude Pro or Max seat this way is explicitly prohibited.

Is OpenCode Go worth $10 against Codex on Plus?

They meter different things. OpenCode Go is $10 a month for a roster of open coding models and counts dollars per model: 20% of that model's monthly limit per five hours, 50% a week, 100% a month. Those monthly limits run $15, $30 or $60, so $60 is the top model's cap, not the plan's. Codex on Plus is $20 and counts messages per five-hour window, with local and cloud work sharing one allowance. Go buys breadth cheaply. Plus buys OpenAI's own models and the rest of ChatGPT.

Codex CLI or the OpenCode TUI: is the terminal the difference?

No, both outgrew the terminal. Codex ships a CLI, an IDE extension, a desktop app, the web and iOS. OpenCode ships a TUI, a desktop app, an IDE extension and a web surface. So "Codex CLI vs OpenCode" compares two front doors to the same shape of agent, and the real fork is the model list behind each one.

How to choose, in one line each

Already paying for ChatGPT, run Codex and add nothing. Want one agent that survives a vendor switch, or local models behind your own gateway: install OpenCode. Add Claude Code to the shortlist in OpenCode vs Claude Code vs Codex, or weigh the two big vendors alone in Codex vs Claude Code. Weighing an editor too, see Codex vs Cursor vs Claude Code or the Codex, Claude Code and Copilot breakdown.

References

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

Alden Menzalji — Sun, 13 Sep 2026 12:53:43 +0000

Short answer: Codex if you already pay OpenAI or want the current leaderboard lead, Claude Code if you want Claude models

Verified September 16, 2026. TL;DR: Codex is bundled into every ChatGPT plan, including the $0 one. Claude Code is included in every paid Claude plan and absent from the free one. Above that the ladders match: $20, then $100 or $200 for 5x or 20x usage. Price rarely decides it. Pick by the models you want and the subscription you already hold; Codex now holds the leaderboard lead, by 0.3 points.

	Codex	Claude Code
Made by	OpenAI	Anthropic
Free tier	ChatGPT Free, $0	None
Entry paid tier	Go $8, Plus $20	Pro $20, or $17 billed annually
Top individual tier	Pro, $100 (5x Plus) or $200 (20x)	Max, $100 (5x Pro) or $200 (20x)
Models	GPT-6 Astra, GPT-5.6 Sol, Terra and Luna, plus GPT-5.5 until it retires Oct 14, 2026	Sonnet 5, Opus 5, Fable 5.1, Haiku 4.5
What it meters	Five-hour window; weekly limits may apply	Five-hour session plus a weekly limit
Runs in	Web, desktop app, CLI, IDE extension, iOS, cloud	Terminal, VS Code, JetBrains, desktop app, web, iOS and Android

What is cheaper, Codex or Claude?

Codex, but only at the bottom of the ladder. ChatGPT Free includes it at $0, Go costs $8 and Plus $20. Claude Code starts at Pro, $20 a month or $17 billed annually, and Anthropic's Free plan does not include it. From $20 up the two match to the dollar: $100 and $200 for the 5x and 20x tiers, and team seats at $20 annual or $25 monthly on both sides.

Two meters that both count time

Both vendors meter five-hour windows, but only OpenAI prints numbers. On Plus, Codex allows 5 to 45 GPT-6 Astra messages per window, 10 to 100 on GPT-5.6 Sol, 25 to 200 on Terra and 250 to 2,000 on Luna; local and cloud work share the window, and weekly limits may apply. Anthropic publishes no counts: every plan resets on a rolling five-hour session, paid plans add a weekly limit, and chat, desktop and mobile share one pool with Claude Code.

Which is better, Claude Code Max or Codex Pro?

Same price, different fine print on the top model. Codex Pro is 5x or 20x Plus: 25 to 225 Astra messages and 50 to 500 Sol per window at $100, 100 to 900 Astra and 200 to 2,000 Sol at $200, plus GPT-5.3-Codex-Spark in research preview. Claude Max is 5x or 20x Pro per session, and it is the individual plan where Fable comes out of the included allowance, at up to half the weekly limit; on Pro, Fable bills to usage credits instead.

Can Codex do what Claude Code does?

Most of it. Both run in the terminal, an IDE and the cloud; both take MCP servers, skills, subagents and scheduled tasks; both sell credits to keep working past a limit. The gap is the model behind the agent. On Terminal-Bench 4.0, released August 28, Codex with GPT-6 Astra leads at 58.2%, Claude Code with Fable 5.1 is second at 57.9%, Opus 5 third at 51.8%, and GPT-5.6 Sol sixth at 37.3%.

How to choose, in one line each

Already paying for ChatGPT, run Codex for nothing extra. Want Claude models, buy Pro; want Fable inside the allowance, buy Max. Adding Copilot? Read the three-way breakdown. Cursor? Codex vs Cursor vs Claude Code. An open source agent? OpenCode vs Claude Code vs Codex. Google's free CLI? Gemini CLI vs Claude Code vs Codex. Not sure you should write the code at all? Run the vibe code or hire check.

References

Introduction to Personalization - What It Is and Why Most Companies Get It Wrong

Alden Menzalji — Thu, 13 Aug 2026 09:27:06 +0000

You search for hiking boots on Monday. By Tuesday, every website shows you hiking boot ads. By Wednesday, you're getting emails about hiking gear. By Thursday, you've sworn off that brand forever.

Hero photo by Andrew Peluso on Unsplash

The Personalization Reality Check Series

Introduction to Personalization (You are here)

Understanding Personalization Factors - Part 1: Data Taxonomy

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.

Welcome to modern personalization: where vendor promises of "400% ROI" collide with Forrester finding consumers "lukewarm" about personalization for the second year running. Where 92% of businesses invest heavily in AI-driven personalization, yet 53% of customers report negative experiences with personalized marketing.

Let's talk honestly about what works, what doesn't, and why most personalization initiatives end up in the project graveyard.

What Is Personalization (Really)?

The industry conflates three distinct concepts:

Segmentation

Who controls it: Marketer
How it works: Groups customers by shared traits (location, purchase history, demographics)
Scale: Targets hundreds or thousands at once
Purpose: Determines whether to market to a customer

Think of it as sorting customers into buckets: "First-time visitors," "Cart abandoners," "VIP customers."

Personalization

Who controls it: System (implicit, no customer involvement)
How it works: Rules or machine learning change each message for unique individuals
Scale: Targets individuals at scale
Purpose: Tailors content to individual interests automatically

Netflix showing "Because you watched..." or Amazon's dynamic product recommendations. Happens without the customer requesting it.

Customization

Who controls it: Customer (explicit, requires conscious input)
How it works: Customer modifies product/service to fit preferences
Scale: Individual
Purpose: Empowers customer choice and control

Nike's NIKEiD where you design your own shoes is customization, not personalization.

Key distinction: Personalization is implicit (happens behind the scenes), customization is explicit (requires action). You can't personalize effectively without first segmenting.

The Current State: A Paradox

The personalization market is booming:

$11.6 billion market for CX personalization and optimization projected by 2026
92% of businesses use AI-driven personalization
Gartner sized the personalization engine market at $1.2 billion in 2024, growing 26%

Here's the other side:

53% of customers get negative experiences from personalized marketing
Those customers are 3.2x more likely to regret a purchase and 44% less likely to buy again
85% of companies believe they personalize well, but only 60% of customers agree

Companies optimize for engagement metrics (clicks, opens) rather than genuine customer value. Customers are noticing.

The ROI Reality Check

The Vendor Promise

You've seen these statistics:

700% ROI from e-commerce personalization
202% better conversion rates from personalized CTAs
Product recommendations driving 31% of site revenues

These numbers are real. They're also outliers.

The Reality

What vendors don't tell you:

"Full-on personalization is complex and time consuming" with months or years of implementation
Data engineers spend 75% of their time massaging data and responding to errors
74% of organizations struggle to scale beyond pilot programs
Returns decline as personalization gets more granular while costs increase

The companies achieving 400-700% ROI have clean data foundations, organizational alignment, resources for continuous optimization, clear metrics beyond vanity numbers, and transparent consent-driven approaches.

Most companies have none of these.

The Privacy Reckoning

The Cookie Crumbles

Google began restricting third-party cookies for 1% of Chrome users in January 2024, reversed the full phaseout in July 2024 after advertiser pushback, then in April 2025 dropped even the planned standalone consent prompt. The direction is still clear:

GDPR and CCPA force transparency
Consent requirements leave analytics blind to a meaningful share of transactions
Third-party data signals are disappearing
First-party data strategies are now critical

The Creepy Factor

Personalization that feels like surveillance backfires, measurably:

53% of customers report negative experiences with personalized marketing
Those customers are 3.2x more likely to regret purchases and 44% less likely to buy again
Customers exposed to personalization are 2x more likely to feel overwhelmed at key decision points

What crosses the line:

Lack of consent - surveillance, not service
Cross-device stalking - "I searched once, now I'm followed everywhere"
Poor timing - messages within seconds of a search
Location tracking - unsolicited location-based messages
Unknown sources - communications from unrecognized companies

Why Personalization Projects Fail

1. Data Quality Nightmares

Customer data scattered across ERP, CRM, marketing automation, analytics. Systems that don't talk to each other. Personalization becomes guesswork based on incomplete, outdated data. Data engineers spend 75% of time on cleanup.

2. Over-Automation Without Oversight

Autoresponders displaying "Hello {{firstname}}" or generic messages at wrong times. 76% of customers frustrated when personalization misses the mark.

3. Scaling Failures

Personalization works for 100 users in testing, breaks at 10,000. 74% of organizations struggle to scale; only 1 in 5 are effective at scale.

4. One-Time Project Syndrome

Treating personalization as "launch and done." Experiences released, team moves on, algorithms stagnate. Personalization requires continuous feedback: data → insights → experiences → new data.

5. Inadequate Segmentation

42% of marketers don't segment at all. You can't personalize without proper segmentation.

Common Misconceptions

"Personalization Only Works for Returning Customers" - First-time interactions can be personalized using page views, clicks, referral source, device type within the session.

"Real-Time Is Too Difficult" - The barrier isn't technical difficulty: it's perceived complexity and lack of champions.

"More Data = Better Predictions" - Data quality and relevance matter far more than volume.

"AI Will Solve Everything" - AI without clean data and human oversight creates automated garbage at scale.

When NOT to Personalize

Without clean, unified data - garbage in, garbage out
Without organizational alignment - siloed teams create fragmented experiences
As a one-time project - requires ongoing optimization
Without consent mechanisms - violates regulations and trust
When simpler segmentation suffices - don't over-engineer
Without clear success metrics - can't optimize what you don't measure

Forrester's 2025 consumer personalization research is blunt: consumers are "lukewarm" about companies' personalization efforts for the second year running. Only 53% of US online adults say they like it when companies personalize interactions, and a third never want it at all.

The Honest Truth About Vendor Marketing

Very few people do personalization well
Even fewer understand what it entails
Product companies won't discuss the months or years required
Gartner predicted 80% of marketers would abandon personalization by 2025. The market kept growing instead, but the frustration behind that prediction was real

Companies succeeding have executive buy-in, clean data, cross-functional alignment, continuous optimization resources, and privacy-first approaches.

The Path Forward

What works in 2025:

Start with segmentation, evolve incrementally
First-party data strategy as foundation
Transparency that builds trust ("Because you..." explanations)
Value exchange for data sharing
Continuous optimization, not launches
Privacy-first positioning as competitive advantage

The 15% seeing ROI aren't doing magic. They're building clean data, aligning teams, iterating continuously, being transparent, and respecting privacy.

That's not sexy. It doesn't make great vendor marketing. But it works.

The Bottom Line

Personalization works when done right: prioritizing customer value over engagement metrics, transparency over surveillance, consent over coercion, continuous improvement over one-time launches.

If you're considering personalization, start with these questions:

Do we have clean, unified customer data?
Are our teams aligned around customer value?
Can we commit to continuous optimization?
Do we have consent mechanisms and privacy compliance?
Can we be transparent about how we personalize?

If you can't answer "yes" to all five, fix those issues first.

The future isn't about personalizing everything for everyone. It's about personalizing the right things, for the right people, at the right time, with their consent.

References

Gartner (2025). "Survey Reveals Personalization Can Triple Customer Regret"
Twilio (2023). "Twilio Research Reveals Scale of AI Surge as 92% of Businesses Flock to the Technology"
HubSpot (2024). "The Death of Third-Party Cookies"
Gartner (2019). "80% of Marketers Will Abandon Personalization by 2025"
Twilio Segment (2021). "The State of Personalization 2021"

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 September 2, 2026.

Originally published August 10, 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 the CLI, VS Code, and JetBrains	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: web and mobile are open to Pro, Max and Team, and to Enterprise where an admin turns it on, cloud execution is still labelled beta, and the Chrome side panel is still rolling out to Pro. Cloud sessions start from what Claude already remembers from your chats, what comes up carries back into chat, and some features stay desktop-only.

OpenClaw is the only one you host

OpenClaw calls itself "an AI assistant that runs on your devices and meets you in the channels you already use", connected "through one Gateway, for a single operator or for a team whose members trust each other". 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 mutually 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 and Hermes vs OpenClaw vs Claude Code first. Still picking a coding agent? Start with Codex vs Claude Code vs GitHub Copilot, or OpenCode vs Claude Code vs Codex. Founders still deciding whether to write the code at all should start with the vibe code or hire check.

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 September 12, 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.

Originally published August 7, 2026.

	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 124,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 207,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 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 per model: 20% of that model's monthly limit per five hours, 50% a week, 100% a month, and those monthly limits run $15, $30 or $60. 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. Just the two open source ones: OpenCode vs Codex. Wider field: Codex vs Cursor vs Claude Code, Gemini CLI vs Claude Code vs Codex, and the Codex, Claude Code and Copilot breakdown. Founders still deciding whether to write the code at all should start with the vibe code or hire check.

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"