sedhu.eth

Engineer, Photographer and a guy who is struggling to live his dreams but stuck in reality. Dev#21 @developer_dao

[Marc Andreessen 🇺🇸 @pmarca]

Oh yeah.

[sedhu.eth @imsedhu]

Google Chrome just silently downloaded a 4GB AI model onto your machine 🤯

No popup. No checkbox. No "hey, mind if we use 4GB of your disk?"

Here's what's actually happening under the hood:

→ Chrome writes a file called `weights.bin` inside `OptGuideOnDeviceModel`
→ It's the full weights for Gemini Nano — Google's on-device LLM
→ It fires during a background update window — batched alongside security patches like it's equivalent
→ If you delete it, Chrome re-downloads it. Every. Single. Time.
→ The only way to stop it? Dig into `chrome://flags` or enterprise policy tooling most users don't even know exists

The kicker? That shiny "AI Mode" pill in Chrome's address bar? It doesn't even USE the local model 😂

It routes everything to Google's cloud servers. The 4GB sitting on your disk powers buried features like "Help me write" in textarea context menus that 99% of users will never discover.

So you're paying the storage cost. You're paying the bandwidth cost. And the most visible AI feature in the browser doesn't even benefit from it.

A privacy researcher verified the entire install chain forensically — macOS kernel filesystem logs, Chrome's own Local State JSON, runtime feature flags, and Google's component-updater logs. Four independent witnesses. Same conclusion.

And this isn't just a Google problem.

Anthropic did the same thing with Claude Desktop — silently installing a Native Messaging bridge into 7 Chromium browsers on every machine where Claude Desktop was installed. No consent. No opt-out. Re-installs on every launch.

Both companies decided your machine is a deployment surface for THEIR product roadmap — not YOUR personal device.

As engineers, we should be especially uncomfortable with this pattern. The install mechanism is designed to survive user deletion. That's not a feature. That's hostility toward your users.

The fix is embarrassingly simple: just ASK. Pop a dialog. "Chrome wants to download a 4GB AI model. Allow or skip?" Two buttons. Done.

Full deep dive by Alexander Hanff (That Privacy Guy) with the forensic breakdown:
https://t.co/3L4qzlPy0o

Have you checked if Chrome dropped this on your machine yet? Run `du -sh` on your Chrome profile's OptGuideOnDeviceModel directory and tell me what you find 👇

#Chrome #GeminiNano #Privacy #Engineering #AI #WebDev #SoftwareEngineering

[sedhu.eth @imsedhu]

OpenAI just open-sourced something that most devs scrolled past without reading the spec 📄

Symphony isn't another AI coding assistant. It's a daemon that turns your Linear board into a self-driving engineering team.

Here's what's actually happening under the hood — because the architecture is where it gets interesting.

Think of it like Kubernetes, but for coding agents instead of containers:

→ Your issue tracker (Linear) becomes the control plane
→ Each ticket gets its own isolated workspace (like a pod)
→ A polling orchestrator watches the board every 30 seconds and dispatches agents to unclaimed work
→ If an agent crashes or stalls? Automatic restart with exponential backoff retries
→ Agents don't just do one thing and stop — they loop through up to 20 turns per issue, re-checking ticket state between each turn

The state machine is what makes this production-grade:

→ Issues move through Unclaimed → Claimed → Running → RetryQueued → Released
→ This is NOT the Linear ticket state. It's Symphony's internal orchestration state — completely separate from your "Todo / In Progress / Done" workflow
→ Reconciliation runs every tick: terminal tickets kill the agent AND clean the workspace. Non-active states stop the agent but preserve the workspace.

The retry logic alone is worth studying:

→ Clean exit? Schedule a 1-second continuation retry to re-check if the issue still needs work
→ Crash? Exponential backoff: delay = min(10000 × 2^(attempt-1), 300000ms)
→ That's a 10s → 20s → 40s → 80s → 160s → 300s (cap) curve
→ Every retry re-fetches candidates from Linear — if the issue disappeared or went terminal, the claim is released

The workspace isolation is the safety net most people skip in their own agent setups:

→ Each issue gets a sanitized directory: only [A-Za-z0-9._-] allowed in names
→ Path validation enforces workspace stays inside the root (no ../ escapes)
→ The coding agent's cwd is ALWAYS the per-issue workspace. No exceptions.
→ Workspaces survive across runs — so the agent picks up where it left off with prior commits, partial code, test results

And the WORKFLOW.md pattern is genius 🧠

→ Your team's entire workflow prompt + runtime config lives in one version-controlled file
→ YAML front matter for settings (polling interval, concurrency, hooks, timeouts)
→ Markdown body for the agent prompt template with Liquid-style rendering
→ Change the file → Symphony hot-reloads without restart
→ Bad reload? Keeps the last known good config and logs the error. No crash.

The real shift isn't the code — it's the mental model.

You stop managing coding agents and start managing work. Linear becomes your engineering operating system. Agents become the runtime.

Some OpenAI teams reported 500% more landed PRs in 3 weeks. But the deeper insight is this: when each code change costs zero human supervision time, you stop hesitating on small improvements. The economics of engineering change completely.

Is this production-ready for every team? No. Ambiguous tickets and judgment-heavy work still need a human in the loop. But for well-scoped, test-covered codebases with clear ticket hygiene?

This is the future of how software gets shipped 🚀

Full spec: https://t.co/pWAJiTbXRO

What's the first thing you'd point Symphony at in your codebase?

#Symphony #CodingAgents #AIEngineering #OpenAI #DevTools #Orchestration #SoftwareEngineering

[sedhu.eth @imsedhu]

Everyone's building multi-agent swarms with fancy orchestration frameworks.

I tried that too. Custom agent pipelines, handoff protocols, state machines to manage which agent talks to which.

Know what actually worked on my production codebase? A dumb bash loop. 🔁

The Ralph Wiggum Loop (named after the Simpsons kid who never gives up) is stupidly simple:

→ Feed your AI agent a task with a prompt file
→ Let it code, test, commit
→ When context fills up, kill it
→ Loop restarts with fresh context
→ Git is the memory. Not the LLM.

Think of it like a potter's wheel. Your code is the clay. If the shape isn't right, you don't build a smarter wheel — you just throw it back on and spin again. 🎯

I've been running this on OrbitxPay's NestJS services and here's what surprised me:

→ It doesn't need to be smart. It needs to be persistent.
→ One task per loop. Trust the agent to pick what matters.
→ Tests are your backpressure — if they fail, the loop self-corrects.
→ Context rot disappears because every iteration starts fresh.

The real mindset shift? Your job isn't to sit IN the loop typing code. It's to sit ON the loop — engineering the setup, the specs, the guardrails that let it succeed. 🧠

Geoffrey Huntley nailed this: software development (typing code) is dying. Software engineering (designing systems, feedback loops, constraints) is more alive than ever.

We went from "I write code" to "I program the computer that writes code."

And that computer costs ~$10/hour in API tokens.

What's your experience been with autonomous coding loops — shipping real stuff or still just demos?

#AIAgents #SoftwareEngineering #ClaudeCode #RalphWiggumLoop #BuildInPublic

[sedhu.eth @imsedhu]

Claude Code just shipped something I've been waiting for 🔥

You can now see your sub-agents working — live — right inside the main terminal panel.

Each agent shows up with its name, what it's doing, how long it's been running, and how many tokens it's burning. All in one glance. No more Ctrl+T guessing games.

Think of it like going from a single thread log to a Kubernetes dashboard for your AI workers.

I've been running custom sub-agents for a while now — architect, qa, security-review, dba — each one scoped to a specific job during code reviews and feature work.

Before this update? I'd kick off 4 agents and stare at a frozen terminal hoping they were doing useful work. The only signal was "it's still spinning." Like sending 4 people into a meeting room with no window.

Now I can see:

→ architect is comparing auth-service vs smf-core db connections (1m 41s, 107k tokens)
→ qa is checking handler spec assertions (1m 21s, 83k tokens)
→ security-review is reading the notify client (53s, 64k tokens)
→ dba is reviewing partner notification webhooks (30s, 48k tokens)

This changes how you think about multi-agent workflows. When you can see which agent is eating tokens and which one finished fast — you start optimizing.

Like having a sprint board for your AI team instead of trusting a black box.

Small UX win. Massive productivity unlock 🚀

What's your sub-agent setup look like? Running any custom agents in Claude Code?

#ClaudeCode #AIAgents #DeveloperExperience #BuildInPublic #SubAgents

[sedhu.eth @imsedhu]

Most backend engineers think race conditions are a "systems programming" problem.

Nah. You're probably writing one every week. 🫠

It's called TOCTOU — Time of Check, Time of Use.

Here's the pattern:

→ You CHECK if the user has enough balance
→ You DEDUCT the amount
→ Between those two lines, another request sneaks in and passes the same check

Congrats, you just let someone spend money they don't have. 💸

Think of it like this:

You check your fridge before leaving for the store. Eggs are there. Great, no need to buy.

But your roommate eats the last eggs while you're driving.

You come home. No eggs. No groceries. Chaos. 🍳

This exact bug is everywhere in backend code:

→ Coupon redemption — apply the same code twice in parallel, get double discount
→ Inventory checks — two users buy the "last item" at the same time
→ Wallet transfers — check balance, then debit, but two requests race through

Just this year, Sylius (e-commerce framework) got hit with a TOCTOU CVE for exactly this — promotion usage limits bypassed via concurrent requests. Parse Server had the same class of bug with MFA recovery codes.

The fix isn't complicated, but it requires thinking atomically:

→ Use DB-level locks (SELECT ... FOR UPDATE)
→ Use atomic compare-and-set operations
→ Move check + action into a single transaction with proper isolation
→ Redis WATCH/MULTI for cache-layer operations

The real problem? Most engineers test with one request at a time. TOCTOU bugs only show up under concurrency. Your unit tests won't catch this. Your integration tests probably won't either.

If your code does a READ → DECIDE → WRITE as separate steps without locking, you have a TOCTOU bug. You just haven't hit it in production yet. 🐴

What's the worst race condition bug you've dealt with in production?

#TOCTOU #BackendEngineering #RaceCondition #SystemDesign #SoftwareEngineering

[sedhu.eth @imsedhu]

TypeScript 7.0 Beta just dropped and this is NOT a regular version bump 🔥

The entire compiler has been rewritten from JavaScript → Go.

The result? ~10x faster builds. That's not a typo.

Here's what you need to know:

→ The compiler now runs parsing, type-checking, and emitting in parallel
→ New --checkers flag lets you control how many type-checker workers spin up (default: 4)
→ New --builders flag parallelizes project reference builds — huge for monorepos
→ strict is now true by default (finally!)
→ target: es5 and moduleResolution: node are gone for good
→ You install it via @typescript/native-preview@beta and use tsgo instead of tsc

Think of it like this — your old TypeScript compiler was a single chef cooking a 10-course meal one dish at a time. TS7 is a kitchen with 4 chefs working simultaneously, each handling different courses 🍳

The best part? It's not a rewrite from scratch. They methodically ported the existing codebase to Go, so the type-checking logic is structurally identical to TS 6.0. Same rules, way faster engine.

Companies like Bloomberg, Canva, Figma, Google, Vercel, and Notion have already been testing it on multi-million line codebases.

Beta label, but production-ready confidence. VS Code extension is already out too.

The stable release is expected within 2 months. If you haven't tried it yet — now's the time 🚀

What's the first thing you'd test TS7 on — your main codebase or a side project first?

#TypeScript #TypeScript7 #WebDev #JavaScript #Programming #GoLang #DevTools

[sedhu.eth @imsedhu]

Most people are talking about the Claude Code leak for the drama.

I'm more interested in the engineering decisions inside it. 🔍

One pattern that stood out: they fire off slow operations at module load time — credential reads, subprocess spawns, network checks — and `await` them only when actually needed.

```js
const credsReady = loadCredentials() // starts NOW
// ... rest of init runs ...
const creds = await credsReady // waits only if not done yet
```

It's called **overlapping I/O with initialization**.

The JS engine is doing synchronous work at startup anyway. Why not use that time for parallel I/O? By the time you hit the `await`, the result is often already sitting there.

Think of it like preheating the oven while you're still chopping vegetables. You're not waiting sequentially — you're stacking work intelligently.

This isn't a new trick. But seeing it deliberately applied across an entire golden path in a production-grade AI tool is a good reminder:

→ Fire slow things early
→ Block on them late
→ Use init time, don't waste it

How many of your service startups are doing this? ⚡

#ClaudeCode #JavaScript #EngineeringPatterns #DeveloperTools #AIEngineering

[sedhu.eth @imsedhu]

Claude is billing you for every word it says. Even the unnecessary ones.

Every time Claude replies with "I'd be happy to help you with that" — that's 8 tokens you paid for.
"The reason this is happening is because" — 7 more tokens gone.
"I would recommend that you consider" — another 7.

Add that up across 100 Claude Code sessions a week.

I've been using caveman — a Claude Code skill that strips all the filler from responses while keeping 100% of the technical accuracy.

Same fix. 75% fewer tokens. 🪨

The before/after is wild:

Normal Claude: "The reason your React component is re-rendering is likely because you're creating a new object reference on each render cycle..." — 69 tokens

Caveman Claude: "New object ref each render. Inline object prop = re-render. Wrap in useMemo." — 19 tokens

Install is one line:
claude install-skill JuliusBrussee/caveman

Then just say "caveman mode" or /caveman to activate it.

Code blocks still come out clean. Technical terms stay exact. What dies: pleasantries, hedging, and filler openers that LLMs love padding responses with.

Anthropic bills per token. Caveman gives you a 75% discount on output. 💰

If you're using Claude Code heavily — this one's worth 5 minutes of your time.

#ClaudeCode #DeveloperTools #AI #TokenOptimization #BuildInPublic

[sedhu.eth @imsedhu]

Most devs ship to production the same way they run localhost.

Same config. Same defaults. Same "it worked on my machine" energy. 🤦

I've done it too. And it always bites you — not on day 1, but on day 30 when something weird crawls in through a door you forgot to close.

Here's what I check now before any app server goes live:

🔥 Firewall & Network
→ Is port 3000/8080 exposed to the internet? Lock it. Only port 443 should be public. Everything else behind a load balancer or VPN.
→ Rate limiting at the gateway — not just in your app code. If someone hammers your /login 10,000 times, your app shouldn't even see the request.

🌐 Domains & TLS
→ Custom domain with valid SSL cert — not a self-signed one.
→ HSTS enabled. Force HTTPS. There's no excuse for serving plain HTTP in 2026.
→ Wildcard certs? Make sure you're not exposing subdomains you forgot about.

📦 HTTP Headers
→ This one gets skipped the most.
→ X-Content-Type-Options: nosniff — stops browsers from guessing your MIME type.
→ X-Frame-Options: DENY — blocks clickjacking.
→ Content-Security-Policy — arguably the hardest to set up right, but the most valuable.
→ Run your domain through https://t.co/SL7v7sOqTw. If it's not an A, you're not done.

📬 Request Body & Payload Limits
→ Your app server will happily accept a 500MB JSON body by default. Don't let it.
→ Set explicit body size limits — NestJS, Hono, Express all default to something sane, but "sane" isn't "secure."
→ Think of it like a bouncer at a club: there's a guest list AND a size limit on what people can bring in. 🎟️

📎 File Uploads
→ Limit file size per upload.
→ Validate MIME types server-side — don't trust the client's Content-Type header.
→ Restrict allowed extensions: .jpg, .png, .pdf — not .exe, .sh, .php.
→ Store uploads outside your web root. Serve them through a signed URL, not a direct path.

📡 Monitoring & Observability
→ Structured logs going somewhere (not just console.log dying silently).
→ Health check endpoint that actually checks DB + cache, not just returns 200.
→ Alerting on 5xx spikes — before your users tell you.

Dev mode teaches you bad habits. Production punishes them. 🚨

The good news? Most of this is a one-time setup. The bad news? Most teams skip it because "we'll come back to it."

You won't. Ship it right the first time.

What did I miss from your production checklist? Drop it below 👇

#backend #webdevelopment #production #appsecurity #engineering #softwarearchitecture

[sedhu.eth @imsedhu]

Cursor 3.0 just changed what an IDE even means. 🚨

Most devs are still thinking "AI helps me write code faster."

That's Era 1 thinking. Cursor just skipped to Era 3.

They're calling it the third era of software development — where fleets of agents work autonomously to ship improvements. You don't write the code. You direct who writes it.

Think of it like this: you went from being a carpenter 🪚 to being a site manager. You're not swinging the hammer anymore — you're coordinating the crew.

The parallel agents feature is the real story here. Running multiple agents simultaneously across different repos changes the workflow from "pair programming with AI" to orchestrating a small engineering team. That's a fundamentally different mental model.

This isn't new thinking though. Claude Code has been doing this from the terminal for a while now. And tools like Superset — which lets you run 10+ Claude Code / Codex agents in parallel across isolated git worktrees — have already been quietly proving the model works. 🎯

Is it perfect yet? No. Early reviewers say it's promising but still maturing. Cost can spike fast if you're heavy with model usage.

But the direction is clear — and most devs aren't restructuring how they work yet.

The bottleneck isn't the agents. It's you still thinking like a coder when the job is shifting to conductor. 🎼

#CursorAI #AIAgents #SoftwareEngineering #BuildingInPublic

[sedhu.eth @imsedhu]

Someone analyzed 6,852 Claude Code session files across 3 months. What they found is a masterclass in how infra optimization can quietly break production AI workflows.

Here's what happened 👇

**The change:** Anthropic rolled out a server-side header called `redact-thinking-2026-02-12` that progressively cut Claude's internal "extended thinking" budget — the tokens it uses to reason before acting.

By mid-February: thinking depth had already dropped ~67%.
By March 10: 99%+ of thinking tokens were fully redacted.

**The behavioral shift was measurable:**
→ Read:Edit ratio collapsed from 6.6x → 2.0x (model stopped reading files before editing)
→ Edits without prior file read: 6.2% → 33.7% of all edits
→ Stop hook violations: 0 → 173 in 17 days (model started dodging tasks, asking permission mid-work)
→ User frustration indicators in prompts: +68%

Think of it like this: you hired a senior engineer who used to study the codebase thoroughly before touching anything. Then quietly, someone halved their prep time. Then quartered it. They're still the same engineer — but now they're editing code they haven't read, breaking things, and needing constant hand-holding.

**The infrastructure irony:**
The goal was probably to reduce per-request compute costs. But reduced thinking triggered a cascade:
- More wrong edits → more correction cycles → more API calls
- Feb: ~1,498 API requests | March: ~119,341 — an 80x increase
- Human prompt count stayed virtually the same (~5,600 vs ~5,700)

A model that thinks deeply and gets it right once is cheaper to serve than one that thinks shallow and retries 10 times.

**The lesson for anyone building with agentic AI:**
Token budget isn't just a cost lever — it's a quality lever. Cut it too aggressively under load, and you don't save compute. You multiply it.

Full data + analysis: https://t.co/D1y39JCSxN

Have you seen this kind of degradation in your Claude Code or agentic workflows? What did your team do — tune prompts, switch models, or just accept the regression? 👇

#AIEngineering #ClaudeCode #LLM #AgenticAI #EngineeringLeadership

[sedhu.eth @imsedhu]

Claude Code just dropped features most devs don't even know exist 🔥

Everyone's talking about `/buddy` (yes, your AI coding pet is real).

But the ones actually worth your time:

→ `/powerup` — animated interactive lessons, right inside your terminal. Claude Code ships so fast that most devs are using maybe 20% of what's there. This fixes that. No browser tab. No docs rabbit hole.

→ `--bare` flag — calling Claude Code in CI or pipelines? Strips all startup overhead (hooks, LSP, plugin sync). Up to 10x faster cold start. One flag. Massive win for automation.

→ `--channels` — Claude needs approval for a tool call while you're away from your desk? Forwards the prompt to your phone. Your pipeline doesn't wait for you.

→ `/effort` — low / medium / high. Controls how hard the model thinks per session. Quick scaffolding? Dial it down. Gnarly async race condition? Crank it up.

→ Cron scheduling — recurring prompts inside a session now. Set it, forget it, come back to done work.

→ `/plan fix the auth bug` — pass a description directly and it jumps straight in. Less ceremony, more shipping 🚀

→ Push-to-talk rebinding — `voice:pushToTalk` is now rebindable in keybindings.json. Set it to something like `meta+k` and it won't interfere with your typing at all.

The `/buddy` pet got a Solana memecoin within hours of launch.

`/powerup` got silence.

That contrast says everything. 🐴

The boring features ship the most value. Always has been.

#ClaudeCode #AITools #DeveloperProductivity #EngineeringLife

[sedhu.eth @imsedhu]

Everyone's picking an AI agent framework.

Most are picking the wrong one for their use case. 🤔

Here's my honest breakdown after going deep on the options:

**The model is the engine. The harness is the car.**

Without the harness — memory, tool orchestration, guardrails, state — your LLM is a powerful engine with no steering.

So which harness do you build on?

---

**🔩 Build your own**
Full control. Your domain rules, your guardrails, your moat.
But Manus rewrote theirs 5 times in 6 months. LangChain rebuilt 4 times in a year. Plan for months, not weeks.

→ Choose this if your use case is highly domain-specific and you can afford the engineering investment.

---

**🧰 Mastra**
TypeScript-native. Memory, workflows, RAG, evals — all built in.
Scored 9/10 DX vs LangChain's 5/10 in a recent benchmark.
Model-agnostic (swap Claude → GPT → Gemini without rewiring).

→ Choose this if you're a TS/Node team building a SaaS product and need to ship fast without reinventing infrastructure.

---

**🔬 Pi (by Mario Zechner)**
4,000 lines of TypeScript. Minimal. Unopinionated.
No sub-agents, no plan mode baked in — intentionally.
The same primitives powering OpenClaw. 2000+ model support.

→ Choose this if you want raw composable primitives, or you're embedding a coding agent *inside* a product, not building the product layer itself.

---

The real trap engineers fall into?

Picking a framework before defining the task boundary.

Define what your agent needs to do reliably at step 50 and step 100 — *then* pick your harness.

The moat isn't the model. It's the harness you build around it. 🏗️

What are you using to build agents right now?

#AIAgents #AgentHarness #TypeScript #BuildingInPublic #LLM

[sedhu.eth @imsedhu]

RAG is great. Until your agent needs to find exact syntax across 10 pages.

That's the wall Mintlify hit with their docs assistant.

Classic RAG would return the top-K chunks that semantically matched the query. But if the answer lived across multiple pages, or the user needed exact code syntax that didn't land in a top result — the agent was stuck.

Their first fix: give the agent a real sandbox + filesystem. Clone the repo, let it explore.

P90 session creation time? 46 seconds. Infrastructure cost at 850K conversations/month? $70K+/year. Just for reading static docs.

So they asked a better question:

Does the agent need a real filesystem — or just the illusion of one?

They built ChromaFs — a virtual filesystem that intercepts UNIX commands (grep, cat, ls, find) and translates them into queries against their existing Chroma DB.

The agent didn't change. The interface did.

→ grep = exact string match against Chroma metadata
→ cat = reassemble chunked pages back into full content
→ ls / cd = resolved from an in-memory path tree. Zero network calls.

Session boot: 46s → ~100ms. Marginal cost: ~$0.

The analogy: RAG is like asking a librarian "find me something about OAuth." A filesystem is like walking to the shelf yourself, opening the book, and reading the exact line. Same library. Completely different interaction model.

The real lesson:

→ RAG retrieves. Filesystems navigate. Agents need both — know when to use which.
→ Don't spin up new infra when your existing DB can do the job differently.
→ The best AI systems in 2026 won't be the most powerful. They'll be the most deliberately designed.

We keep defaulting to "add more RAG, add more context." Sometimes the unlock is just changing how the agent moves through information. 🧠

#AIAgents #RAG #SystemDesign #EngineeringThinking #BuildInPublic

[sedhu.eth @imsedhu]

Last week I was building a payment flow and Claude was doing its usual thing — writing decent code, suggesting patterns.

Good. But not great.

Then I plugged in a marketplace (obra/superpowers). And Claude went from "helpful assistant" to "senior engineer who actually knows TDD." 🧠

Think of Claude Marketplace like an app store for your AI. You browse, install, and suddenly Claude has new superpowers — skills, agents, MCP servers, hooks.

Here's how it works in 3 steps:

→ Step 1: Add a marketplace
Run this in Claude Code:
/plugin marketplace add owner/repo

→ Step 2: Browse & install
Type /plugin → hit the Discover tab → click Install on what you need.

→ Step 3: Use the skills
Type "/" or "+" in Cowork and your new skills show up. That's it.

Now the real question — which marketplaces are worth adding?

Here are 4 GitHub repos I'd recommend:

🔹 anthropics/claude-plugins-official (15k+ ⭐)
The official one. Curated by Anthropic. Includes Slack, GitHub, Linear, Supabase connectors + code review skills. Start here.

🔹 obra/superpowers (120k+ ⭐)
The beast. TDD-first development, systematic debugging, subagent-driven workflows. This one alone made Claude feel like a 10x pair programmer. 🐴

🔹 Chat2AnyLLM/awesome-claude-plugins (834 plugins, 43 marketplaces)
The aggregator. If you want to discover what's out there — this is your directory. One repo to find them all.

🔹 rohitg00/awesome-claude-code-toolkit (135 agents, 150+ plugins)
The kitchen sink. Was #1 trending on GitHub last month. 42 commands, 19 hooks, 8 MCP configs. If you want everything, go here.

Real talk — before marketplaces, I was copy-pasting CLAUDE.md rules from random blog posts. Now I just run one command and Claude levels up instantly.

If you're using Claude Code without a marketplace, you're driving a Tesla in first gear. 🚀

Which plugins are you running? Drop them below 👇

#ClaudeCode #AITools #BuildInPublic #Plugins #DevProductivity

[sedhu.eth @imsedhu]

We spent hours debugging a 401 error that only showed up in our new stack. 😤

Locally? ✅ Integration tests? ✅ Deployed? ❌ Every. Single. Time.

The setup: NestJS API with HMAC signature verification. `rawBody: true` to capture raw request bytes. esbuild bundles everything into one file. AWS CodePipeline handles the rest.

The weird part — GET requests passed fine. Only POST requests failed. `req.rawBody` was always `undefined` on the server. Never locally.

We added debug logs. Tried explicit Express verify callbacks. Nothing worked.

Then I uploaded our locally-built bundle directly to S3 and pointed the server at it.

It worked. 🤯

So I compared bundle sizes — local was 9.7MB, server was 8.9MB. Same source code. Same lockfile. Different bundles.

Turns out the pipeline was running esbuild **twice** — once in Build, once in Deploy. Two different CodeBuild containers. Two structurally different outputs. The Deploy bundle quietly broke NestJS's internal wiring between `@nestjs/platform-express` and Express's body parser verify callback.

Think of it like two chefs following the same recipe in different kitchens — same ingredients, but one kitchen's oven runs slightly hotter and the dish comes out wrong. 🍳

The fix: move esbuild to the Build stage only. Deploy stage just ships the artifact. Build once. Test it. Deploy those exact bytes.

**The lesson:**

Never rebuild in your deploy step. The artifact that passes your tests should be the exact bytes that run in production. Two identical build commands in two different CI containers can produce functionally different output — especially with bundlers merging entire dependency trees. 🎯

If it's not the same file, it's not the same test.

[sedhu.eth @imsedhu]

Starting with AWS CDK? Protect your data layer first. 🔐

Before writing a single Lambda or API Gateway construct, lock down every stateful resource:

→ `RemovalPolicy.RETAIN` on every database (RDS, DynamoDB, DocumentDB)
→ Same for EBS volumes, S3 buckets, ElastiCache clusters
→ Same for Elastic IPs and DNS records — anything other services point to by address

CDK's default is `RemovalPolicy.DESTROY`. A renamed security group, a modified subnet, an updated instance type — any of these can trigger a resource replacement. For a database, that means data loss.

Also add termination protection to every prod stack:

```
new MyStack(app, 'ProdStack', {
terminationProtection: true,
});
```

One line. Prevents accidental stack deletion via `cdk destroy` or the console.

3 rules I follow on day one of every CDK project:

1. Every stateful resource gets `removalPolicy: RETAIN` — no exceptions
2. Enable `terminationProtection: true` on every prod stack
3. Route all deploys through a pipeline with a manual approval step — never `cdk deploy` straight from a laptop

`cdk diff` will show "replace" when a destructive change is coming. Treat it like a security review, not a formality. 🐴

#AWS #CDK #EngineeringLessons #CloudEngineering #BuildingInPublic

[sedhu.eth @imsedhu]

Most devs don't know this Claude Code shortcut exists.

I was running Claude Code in approval mode, and it paused to ask permission for something — a bash command I genuinely couldn't make sense of. I didn't know if I should say yes or no.

Then I hit Ctrl+E.

Game changed. 🎯

Here's what Ctrl+E actually does and when to use it:

→ What it is: When Claude Code pauses with a permission prompt, Ctrl+E triggers an "explain" — Claude breaks down exactly what it's about to do, why it needs that permission, and what the impact will be.

→ Real-world analogy: Imagine a contractor knocking on your door asking "can I go into the basement?" — Ctrl+E is you saying "explain why before I hand you the key." 🗝️

→ When to use it: Any time Claude Code surfaces an approval prompt with a command or operation you don't immediately recognize — before blindly hitting yes or no.

→ What it's NOT: Ctrl+E in a normal text input just moves your cursor to the end of the line (standard bash behavior). The explain feature is only active when you're on a permission prompt.

→ Why this matters in approval mode: Approval mode makes Claude ask for confirmation at every step. That's powerful — but only if you understand what you're approving. Ctrl+E closes that gap.

The permission system in Claude Code isn't just a speed bump. It's your last line of defence before Claude touches something you didn't intend. 🛡️

Use Ctrl+E. Know before you approve.

#ClaudeCode #AITools #DeveloperTips #BuildingInPublic

[OrbitX @OrbitX_Pay]

Agents are already moving money. The question is - on what rails?

This Thursday, we get into the real talk around autonomous agents, agentic payments, and what borderless banking actually looks like when AI is in the loop.

→ @zeeshan_utd - DevRel & AIxCrypto builder.
The guy who actually thinks about what happens when agents hold wallets.

Moderated by @ThePrayasu , Global Ecosystem Lead @OrbitX_Pay.

Thursday, Mar 26th, 2026 06:30 PM IST | 01:00 PM UTC | 05:00 PM GST

RSVP below 👇