DEV Community: yaniv zalevas

I open-sourced the cockpit we used to understand huge engineering departments in days

yaniv zalevas — Sat, 19 Sep 2026 09:07:13 +0000

My name is Yaniv, and I run Codpal, a CTO-as-a-service company. Over the years we've walked into a lot of new companies, and we always needed the same thing: a fast understanding of how engineering actually runs — what's in the roadmap, what the developers are focused on, who the main developers carrying the work really are.

Every engagement started with weeks of meetings to map what the data could have told us in hours.

So we built the tool

Deckgauge pulls Jira, GitHub, GitLab and Azure DevOps into a single data warehouse of development information, and gives you the cockpit picture:

DORA metrics — deployment frequency, lead time, change failure rate, time to restore, computed from your actual delivery data
Team Focus — what every team is actually working on vs. what the roadmap says
Per-engineer workload — who's carrying the delivery, who's drowning
CapEx vs OpEx — how much of engineering is building the future vs. keeping the lights on
One board over all four trackers, with org-chart views

It let us sit with division leads on day one and speak their language — with real data instead of guesses.

The part you might find interesting

Deckgauge was largely built by AI agents (Claude Code with an agent workflow) — human-reviewed on every merge. The tool that measures engineering is itself an experiment in AI-built engineering. Scroll the commit history; it's the artifact.

As featured on YouTube

The Next New Thing (56K subscribers), a weekly show covering the best GitHub repos, featured Deckgauge — demoing the board live and taking on the "why not just Jira?" question:

🎬 https://youtu.be/1fHsIveXRa8?t=1445

We open-sourced it

It worked so well we decided it's a gift for everyone to use:

🔗 Repo: https://github.com/Codpal-Limited/deckgauge
🎮 Live demo (fictional 25-person org): https://demo.deckgauge.com
🌐 Site: https://deckgauge.com

Fully self-hosted — single Docker deploy, nothing leaves your infrastructure. In a world where every engineering-metrics SaaS wants your ticket data in their cloud, we think that matters. License is FSL-1.1 (free for any use except offering it as a competing product; converts to Apache-2.0 in September 2028).

If you're an engineering leader who wants visibility without the vendor cloud, or you just want to see what an AI-agent-built codebase looks like — take it for a spin. Feedback welcome, especially the critical kind.

Cross-post note: this continues the AI-agents journey from my earlier posts here — the tool that measures engineering is itself an experiment in AI-built engineering.

Two Failures, One Lesson: Designing AI Agents for the Bad Day

yaniv zalevas — Tue, 23 Sep 2025 08:51:12 +0000

*TL;DR *
Our first truly organic user tried Agents24x7, hit a known edge-case bug, churned, came back after we fixed it—then ran straight into provider downtime. We shipped a multi-LLM circuit breaker, “never-500” UX, and incident playbook. Takeaway: build for degraded modes first. Consistency > perfection—for users and founders.

Context
We’re building Agents24x7: autonomous content ops for small teams (keyword research → outlines → drafts → internal links → scheduled publish to Shopify/WordPress + socials). We dogfood daily.

Then it happened: our first stranger installed and created her first post.

Failure #1 — The backlog came due
Edge case: “update the same document after feedback” sometimes failed (draft pointer vs published pointer).

We’d parked it while pushing “strategic” features (social posting, multi-lang).

She triggered it on her first edit → fail → bounce.

What we did: agent alerted us → we hotfixed, wrote a human email, apologized, added trial credits, invited her back.

She returned. Confidence restored… briefly.

Failure #2 — Provider downtime at the worst time

We already knew LLMs blip. Our roadmap included a gateway to fail over from Claude → ChatGPT/Gemini gracefully.

She retried exactly during a Claude outage. Murphy clocked in. Another failure surfaced to the user. She bounced again.

Not “our fault”—but absolutely our responsibility.

What we shipped (fast)
1) Multi-LLM Circuit Breaker

Health checks + latency thresholds per provider

Automatic failover to secondary model on soft fails

Idempotent requests + retries (expo backoff)

Quality banner in UI: “Draft created in reduced-capacity mode—please skim.”

2) “Never-500” UX for Content

If a job can’t finish within X sec: save partial + context

Offer “Finish later” or “Try backup model now”

Clear, human error copy + automatic credit comp for severe incidents

3) Observability That Support Can Use

Error taxonomy: USER / AGENT / PROVIDER / NETWORK

Timeline per doc: inputs → model → outputs → publish status

On-call routed from agent events, not just backend logs

4) Release Hygiene

Flags for risky flows (update-in-place, multi-edit)

Dogfood → canary cohort → GA

Lightweight incident playbook (who fixes, who writes, who posts-mortems)

Design principle we’re adopting
Degraded > Dead.
For creation tools, a mediocre draft + clear banner beats a spinner that never ends. Users forgive “reduced mode”; they don’t forgive “I lost my work.”

Founder notes (the headspace part)

Decks promise linear progress. The field delivers dice rolls. Your job isn’t to avoid every rare event; it’s to limit blast radius and recover with dignity—then keep shipping.

Don’t re-order your whole roadmap for every fire. Assign a fixer, keep one person shipping.

Communicate like a human (own it, explain, make it easy to try again).

Build systems that assume the cloud gremlins will visit exactly during a demo.

What we’re seeing now
Update-in-place bug: fixed.

Circuit breaker: live.

Partial-save + clear errors + comp flow: live.

That first organic user? Back and publishing again. We still dogfood daily.

If you’re building agentic tools, steal this checklist

Never-500 core flows (save partial, resume later)
Multi-provider routing with health checks + timeouts
Idempotent jobs + retries + backoff
Explainability artifacts (brief, links, decisions) for reviews
User-readable timelines for support
Feature flags + dogfood + canary
Incident comms templates + automatic credit comp

Why this matters for the future
Agent UX isn’t about sharper prompts—it’s about time and trust. If agents keep the schedule and fail gracefully, small teams can publish like bigger ones and earn compounding organic traffic. That’s a future worth building.

Happy to compare notes on circuit breakers, prompt versioning, and degraded-mode UX.

The Near Future of Content Ops: AI Agents That Keep Time

yaniv zalevas — Fri, 19 Sep 2025 12:15:41 +0000

TL;DR: The next wave of marketing automation isn’t better prompts—it’s autonomous agents that keep schedules. We built one: Agents24x7, a Shopify SEO app (with a WordPress plugin for SEO blog posts) that researches topics, writes, links internally, and automates blog publishing on a cadence you set. The result: consistent output → compounding organic traffic.

Why “consistency” is the real frontier
Search engines reward topical depth and freshness. The constraint for small teams isn’t knowing what to write; it’s shipping on time, every time. We don’t lose to competitors on creativity—we lose on cadence.

That’s a systems problem, not a copy problem.

From LLMs to “clocked agents”
Most teams tried this progression:

Prompt a model → decent draft
Add style guidelines → slightly better draft
Still miss the calendar → traffic stalls

What actually changes the curve is a clocked agent: something that plans topics, drafts, formats, links, and publishes automatically, with clear guardrails and escalation. The agent’s core feature isn’t language—it’s time.

Our approach (and what we’ve learned)
We built Agents24x7 to behave like a dependable teammate:

Learns your brand & products (ingests your one-pager, policy pages, FAQs).
Prioritizes topics by intent + difficulty, focusing on winnable queries.
Drafts SEO-optimized posts (headlines, H2/H3, internal links, meta, FAQ).
Schedules/Publishes to Shopify or WordPress—daily if you want.
Reports back each morning: what shipped, what’s next, what needs a human call.

Think CI/CD for content: small, frequent releases with a visible pipeline.

This turns “remember to post” into infrastructure.

Guardrails > vibes
Automation without boundaries is how brands go off the rails. We harden with:

Style sheet & “never say” list (brand-safe by default)
Fact store for product, shipping, returns (no invented pricing)
Cannibalization checks to prevent overlapping keywords
Escalation rules for sensitive claims and competitor comparisons

Humans review edge cases, not every comma.
Why this matters for the long tail
The future we want: a one- or two-person shop can match the beat of a 5–10 person content team—without pretending. When AI agents for content consistency keep time, small businesses finally compete on ideas and product, not merely output.

This levels the playing field more than any headline “AI feature.”

A tiny playbook you can steal this week

Map 2–3 pillars + 5–8 clusters each (questions customers actually ask).
Commit to a cadence (2–5 posts/week).
Automate the routine (keyword brief → draft → internal links → publish).
Keep a human in the loop for tone, claims, and product nuance.
Measure what matters: posts/week, first-pass approval rate, internal link coverage, non-brand clicks.
Consistency first, sophistication second.

Where we’re headed next

Plug in your data, get repeatable wins: Connect Google Analytics/Search Console and let agentic AI learn from your actual results—then replicate what works across new topics, pillars, and formats.
Inventory-aware content ops: Tie catalog data to editorial choices—prioritize best-selling products, pause low-converters, and automatically remove targeted words/links when items are out of stock.
Social autopilot (with taste): One draft → tailored posts for Facebook and X, scheduled alongside your blog cadence, with UTM tracking back to your store.
Insight → action loop: Dashboards that highlight what’s compounding (queries, posts, internal links) and one-click actions to spin up similar pieces, refresh decaying pages, or expand winning clusters.

Try it (or just borrow the system)

If your question is “How do I grow my organic traffic on my Shopify store?” the unglamorous answer is: ship on schedule around buyer-intent topics. If that keeps slipping, automate it.

App: https://apps.shopify.com/agents24x7

Keywords for discoverability (kept natural): Shopify SEO app, AI agent for content consistency, automate blog publishing, WordPress plugin for SEO blog posts.

Happy to compare notes on pipelines, guardrails, or how to make agents accountable to a clock. The future isn’t chat—it’s clocked.

Automating Blog Consistency with AI Agents

yaniv zalevas — Thu, 18 Sep 2025 15:02:29 +0000

As developers, we’ve all built great projects that never got traction.
Often the missing piece isn’t the product — it’s the marketing.

One of the most reliable ways to drive organic traffic is through SEO and blogging. But here’s the catch:
👉 Writing a blog post takes hours.
👉 Publishing consistently (daily or even weekly) is nearly impossible when you’re coding, shipping, and supporting customers.

Big companies solve this with teams of writers + SEO specialists.
Indie devs and small businesses? We usually don’t have that luxury.

The Problem We Wanted to Solve
We realized the bottleneck wasn’t knowing what to write — it was the time and consistency to actually do it.

If you’re running a Shopify store or a WordPress site, you need:

Keyword research

Competitor analysis

SEO-optimized content

Publishing schedules

Doing that manually is overwhelming.

What We Built: Agents24x7
So we built Agents24x7, an AI agent platform designed to act like a content teammate.

It learns your business profile.

Does keyword + competitor research.

Writes SEO-friendly blog posts.

Publishes them automatically to Shopify or WordPress.

Works 24/7 — no breaks, no burnout.

For us, this solved the biggest gap: consistent content output without extra overhead.

Why This Matters for Devs & Indie Hackers
As builders, we tend to focus on product. But products don’t grow in the dark.
SEO and organic reach are still powerful, but only if you can keep up with content.

Automating blog consistency means:

More visibility for side projects.

More organic traffic for client sites.

Less time spent on non-coding tasks.

Open Question to the Community
I’d love to hear from other devs:

Have you automated parts of your marketing?

Do you think AI agents can fully replace manual blogging?

Or do you prefer to keep content 100% human-written?

⚡️ For anyone curious, we made Agents24x7 available as a Shopify app and a WordPress plugin — so even non-technical teams can use it. But I’m here mostly to share the problem and hear your thoughts on automation in content.

How I Solved the “Consistency Problem” in Shopify & WordPress SEO with AI Agents

yaniv zalevas — Thu, 18 Sep 2025 11:08:40 +0000

One of the hardest parts of running an online business is publishing content consistently.
If you’ve ever tried to grow a Shopify store, WordPress site, or side project, you probably know this pain:

You start with excitement, maybe publish a few blog posts.

Then real life kicks in → managing orders, improving products, handling customer requests.

And suddenly… weeks go by without a single new article.

The result?
Your SEO growth stalls. Your organic traffic flatlines. And Google quietly moves on to sites that publish more often.

Why Consistency Matters
SEO isn’t about publishing one great article.
It’s about publishing relevant, optimized content regularly so Google (and now AI search) sees your site as active, authoritative, and trustworthy.

That’s why the phrase “Consistency is the hardest part of content marketing” resonates with so many founders and developers.

But the truth is → most small teams don’t have the time, budget, or energy to keep it up.

Enter AI Agents for Content
Over the last year, we’ve seen AI help with coding, customer support, even design.
But what if an AI agent could:

Research your competitors
Analyze your business profile
Do keyword research
And then actually write + publish blog posts daily

That’s the problem I set out to solve.

The Agents24x7 Approach
I’m part of the team behind Agents24x7, a platform that builds AI agents designed to take over repetitive business tasks.

For Shopify and WordPress, we created an agent specifically for SEO content.

Here’s how it works:

Keyword Research & Competitor Analysis → The agent scans what works in your niche.
SEO Content Creation → Drafts blog posts optimized for ranking.
Automatic Publishing → Posts directly to your Shopify blog or WordPress site.
Daily Consistency → No off days. Posts go live every day at your chosen time.
In other words: it’s like having a 24/7 content teammate that never forgets to hit “publish.”

Why This Matters for Developers
If you’re building for yourself or clients, you already juggle:

Code maintenance
Bug fixes
Feature requests
Customer feedback

Content marketing usually gets pushed to “later.”

By automating it, you can focus on building, while still growing your organic traffic in the background.

Where to Try It
The app is available as:

A Shopify app → Agents24x7 on Shopify

A WordPress plugin

If you’ve struggled with staying consistent in your marketing, this might save you a lot of late nights.

Final Thoughts
This isn’t about “AI replacing humans.”
It’s about AI augmenting small teams so they can compete with giants who have full-time content teams.

For me, solving the consistency gap in SEO has been one of the most impactful uses of AI agents so far.

I’d love to hear how you handle consistency in marketing for your projects. Do you batch content? Outsource it? Or maybe you’ve tried building your own automation with n8n, Zapier, or custom scripts?

Let’s discuss 👇