• Laravel Pennant: A Practical Guide to Feature Flags: This hands-on guide to Laravel’s first-party feature flag package covers the parts that tend to cause trouble. It shows how Feature::for($user->team) scopes flags above the individual user, why a null scope skips the closure unless the type is nullable, and how non-boolean values support lightweight A/B tests. It also treats each flag as temporary scaffolding and recommends deleting it in the same PR that completes the rollout.

• Laravel WhatsApp: Two Backends Behind One Facade: This package wraps Meta’s official Cloud API and an unofficial whatsapp-web.js Node sidecar behind one WhatsApp:: facade, so application code does not need to know which backend handles a message. Its trade-off table is useful: the Cloud API offers business templates and official support but lacks groups and limits free-form replies to 24 hours; the web sidecar supports groups, QR pairing, and unrestricted timing through a personal account without official backing. An optional Livewire admin UI is available with Flux.

• You Probably Don’t Need a Database Per Tenant: Ollie Read examines multitenancy strategies from fully separate instances to one discriminator column, with the isolation and operational cost of each spelled out by database engine. His central distinction is useful: isolation concerns security and correctness, while separation concerns storage. PostgreSQL row-level security can provide meaningful isolation without the cost of a separate database. He frames the decision around the amount you are willing to pay per tenant for that isolation over the system’s lifetime.

• Composer in Docker: Best Practices for Production Images: This detailed checklist keeps Composer out of the final production image. It covers bind-mounting the binary, ordering COPY instructions so dependency layers cache separately from code changes, using build secrets instead of ENV for private-package credentials, and pinning the Composer image to a digest rather than a mutable tag. The final Dockerfile combines the techniques into a reusable template.

The post 4 Laravel & PHP Packages That Actually Solve Real Problems appeared first on Cristian Nebunu.

• I Ported Kubernetes to the Browser: Sam Rose generated almost 100,000 lines of TypeScript with LLMs to build webernetes, a partial Kubernetes port that runs entirely client-side: pod scheduling, cluster DNS, and a browser-based container runtime. His verification process is more interesting than the port itself. He reviewed the generated code line by line against the Kubernetes Go source and ran hundreds of integration tests against both webernetes and a real k3s cluster to prove behavioral parity. The weekly token-cost and lines-of-code charts show what a two-month AI-assisted build actually costs.

• ua-tracer: What Does a User Agent Actually Do?: Paul Kinlan built a tiny site that mints a unique, secret-scoped URL on every page load so it can report whether a visiting bot parsed your CSS, followed your manifest, or executed your JavaScript. The early results differ by crawler: GPTBot follows CSS but skips JS, OAI-SearchBot runs full JS, ChatGPT-User does neither, and ClaudeBot fetches everything but stops short of parsing the stylesheet. This tool makes the mechanics of an AI “reading” a page visible.

• Lore Architecture Docs: Lore is a transparent HTTP proxy between a coding agent (Claude Code, Codex, OpenCode, or Pi) and its upstream LLM provider. It captures conversations in three memory tiers: raw temporal storage, distilled observation logs, and curated long-term project knowledge. Its five-layer “gradient context manager” decides how much context to compress from the actual cost of cache reads and writes on each turn. That makes context management an explicit economic decision.

• WSL Container Is Now Available for Public Preview: Microsoft has built a native Linux container CLI (wslc) and matching API into WSL. Windows apps can now run Linux containers without putting Docker Desktop in the middle. The new default filesystem (virtiofs) doubles Windows file-access speed, and the preview already works with VS Code Dev Containers. I’ll try it on the Windows machines where I currently keep a separate Docker installation just for Linux containers.

• Fastbelt Version 0.1: TypeFox’s new language engineering framework, a Go successor to Xtext and Langium, has reached its first real release. It includes grammar tooling, automatic cross-reference resolution, parallel workspace builds, and core LSP features such as completion, go-to-definition, and hover. TypeFox claims up to 50 times the speed and one-twentieth the memory use of comparable frameworks on common workloads. Anyone who has built a custom language server will recognize how much boilerplate that could remove.

• Data-Oriented Design in Yuku’s Parser: Arshad Yaseen’s JavaScript/TypeScript parser, written in Zig, handles an 8MB file in about 19ms by storing its AST as flat arrays of u32 indices instead of a pointer tree. It needs no per-node malloc, traversal stays cache-friendly, and the whole tree frees in one call. Because each child is appended before its parent, a linear pass over the node array is already a post-order traversal. Yaseen also explains why Yuku applies the technique less rigidly than Zig’s compiler: Yuku’s AST is a public API that other tools must use.

• Cloudflare Workers and Hyperdrive with TanStack Start: Part 2 of Adam Rackis’s Cloudflare series covers two recurring database problems on Workers. Hyperdrive’s connection pooling reduces the cost of connecting on every invocation, while TanStack Start’s global request middleware creates a fresh “connection” per request to satisfy Workers’ rule against persistent I/O resources. He also pins the Worker’s placement region to the database region, a small configuration detail with a direct latency cost when missed.

The post AI Agents & Systems Engineering: 7 Bookmarks Worth Your Attention appeared first on Cristian Nebunu.

• Oh My Posh Visual Configurator: A drag-and-drop builder for your terminal prompt: arrange segments, preview in real time, and export the config for PowerShell, Bash, Zsh, or Fish. If you’ve ever wanted to prettify your prompt but bounced off hand-editing a JSON theme, this removes that friction. Small, but the kind of thing that makes the terminal feel like yours.

• MonoLisa: A coding font with a live tester page where you can preview it in real code, toggle every OpenType feature (ligatures, stylistic sets, the grade axis, alternate glyphs), and try it across JavaScript, CSS, Java, PHP, and Python. The font itself is premium, but the tester is free and useful for deciding whether a wider, more characterful mono is worth the switch. Readability is the whole game when you stare at code all day.

• Surprising Economics of Load-Balanced Systems: Marc Brooker’s piece is older (2020) but exactly the kind of evergreen theory worth carrying around. The setup: c single-slot servers behind a load balancer, offered load scaling linearly with c to keep per-server utilization constant. What happens to latency as c grows? The intuitive answers (constant, or worse) are wrong: via the M/M/c queue and Erlang’s C formula, mean latency decreases, asymptotically approaching pure service time, and the percentiles follow. Bigger fleets get better latency at the same utilization, and most of the benefit arrives at modest c. One of the rare distributed-systems results where scale makes a problem easier. File it next to your capacity-planning instincts and recalibrate them.

The post A visual builder for your shell prompt, a coding font tester, and the counterintuitive economics of load balancing appeared first on Cristian Nebunu.

• 20+ Best Free Minimal WordPress Themes: Speckyboy’s roundup is exactly what it says: a curated list of clean, typography-first themes (McLuhan, Integer, Koji, Rams, and more), with a handy comparison table at the end. Nothing fancy, but a good bookmark if you or a client ever needs a distraction-free blog or portfolio theme without paying for it.

• WordPress Block Themes Were Made for AI and Using ChatGPT as a WordPress Page Builder: Jamie Marsland’s two Pootlepress pieces are a pair, so I’m keeping them together. In the first he rebuilds his wife’s yoga studio site with ChatGPT and comes away convinced that block themes’ semantic template-plus-content architecture is exactly what makes them AI-generable in a way classic themes never were. The second is the step-by-step version of that claim, his argument being that ChatGPT might be the best WordPress page builder he’s used, purely because of the speed of creative iteration. Read together they’re a good snapshot of where the WordPress-plus-AI conversation actually is right now.

• JSON-LD Explained for Personal Websites: Ethan Hawksley’s guide is the most immediately actionable thing here for your own site. It’s a copy-paste walkthrough of the structured-data nodes that actually move the needle (WebSite, Person, WebPage/ProfilePage, SoftwareApplication, BreadcrumbList, Blog, BlogPosting) with the real JSON-LD from his site for each, and clear notes on @id linking, sameAs for disambiguation, and the fact that crawlers merge nodes across pages by ID while single-page scrapers (LLMs) don’t. Google isn’t the only reader anymore: answer engines read this too when deciding who to cite. If your site’s JSON-LD is thin, this is a weekend win.

• DashboardStack: This one rounds it out on the app side: a CLI that scaffolds a database, auth, CRUD, forms, and Stripe billing for Next.js, Nuxt, or TanStack Start, then deploys to Cloudflare Workers/D1/R2. It does this deterministically, so you’re not burning AI tokens regenerating the same admin plumbing on every project. It’s from the maker of Nuxt Charts, and you own the code outright. A nice “start with the dashboard you’d have built eventually” tool.

The post Minimal WordPress themes, whether block themes were made for AI, ChatGPT as a page builder, JSON-LD for personal sites, and a dashboard-scaffolding CLI appeared first on Cristian Nebunu.

• Multi-Agent Coding Without Worktree Chaos: David Wells’ post is the most useful workflow piece I’ve read in a while. He went all-in on git worktrees for multi-agent coding, then drifted back to a single branch, because worktrees defer collisions to merge time rather than removing them. His answer is coordination: plan the work, interrogate the model for non-obvious questions, turn the plan into a directed task graph, then let a swarm pick up unblocked nodes while a coordinator (“ring leader”) loops every few minutes. Explicit file reservations and an agent mailbox for blockers prevent collisions, so there’s no git status archaeology. The line that stuck: “opening more terminals is not a system.” This is structured parallelism, and it’s clearly where the gains are.

• Herdr: Billed as “tmux for coding agents,” it’s the natural companion to Wells’ approach. It’s a Rust binary (no Electron, no account, no telemetry) that runs your agents in real PTYs on any box, keeps them alive when you close the laptop, shows blocked/working/done/idle state at a glance, and lets you reattach over SSH from your phone. It has real panes, a plugin marketplace, and a CLI + socket API so agents can orchestrate the multiplexer themselves. If you’re running the kind of swarm Wells describes, this is where it lives.

• Two Qwen3 Models on One DGX Spark: Devashish’s post is the deep-systems entry for anyone chasing local inference. The goal: run Qwen3-Next-80B-FP8 for heavy work and Qwen3-4B for fast turns coresident on one Spark (119.67 GiB unified memory), behind a LiteLLM proxy on a single endpoint. It took a weekend, and the write-up is the “residency math” pain: gpu_memory_utilization is a snapshot against total card memory, not free memory; Qwen3-Next is mostly Mamba, so KV-cache demand is dominated by Mamba state alignment, not attention KV; and coresident processes race instead of negotiating. Niche, but if you’re eyeing a Spark to own your inference, this is the hard-won map.

• SEO Content Generation skill: Josh Pigford’s Agent Skill is a self-contained content engine: drop it in ~/.claude/skills/, and each run researches what to publish next, picks the content type, writes one deeply-researched on-brand piece, and registers it in a dedup ledger. It’s built for 2026 search, optimized to rank in Google and get cited by ChatGPT/Perplexity. The “decide → research → write → verify → register” loop is worth studying even if you never run it.

• unslop-text: A skill that strips the cues that make prose read as AI-generated (the em dash, “it’s not just X, it’s Y,” sycophantic openers, delve/tapestry diction, the “in conclusion” wrap-up), and warns against the newer over-corrected “trying not to sound like AI” register (forced fragments, fake typos, bolted-on swearing), which it treats as its own tell. It’s grounded in a Reddit analysis of what readers actually name as giveaways, ships a deterministic scanner for CI, and is honest that the real tells (uniform rhythm, empty fluency) are structural and need a human ear.

The post Multi-agent coding without worktrees, a tmux for agents, two LLMs on one Spark, and two Agent Skills worth stealing appeared first on Cristian Nebunu.

• Cranking View Transitions Up to 11: Bramus Van Damme’s write-up of his Beyond Tellerrand talk (slides and a recording of the sister talk are linked). The premise is delightfully reckless: push the View Transition API past its documented limits by combining it with scroll-driven animations, triggering it automatically with a MutationObserver, even resurrecting classic IE’s page transitions through this modern API. It’s the tinkerer’s tour of the feature, and coming from a Chrome DevRel engineer it’s the good kind of “here’s what happens when you ignore the spec’s guardrails.”

• Modern CSS Theming: Una Kravets’ piece is the one to actually implement. She combines three newly-Baseline features into a nice theming system: light-dark() as the macro foundation (it reads computed color-scheme, so it’s inherited and composable, not a media query), a per-shadow-layer trick to swap drop shadows in light mode for glowing borders in dark, contrast-color() for one-line accessible text on any background, and @container style() queries that branch into hue-tinted palettes instead of harsh black/white. An optional @function --elevation() cleans it up at the cost of narrower support. This separates page-level theming from per-card micro-theming in a way I hadn’t seen laid out so cleanly.

• field-sizing for selects: Manuel Matuzovic covers a small, satisfying fix for an old annoyance: by default a <select> is as wide as its longest option, so a control showing “Utrecht” stays as wide as “Scheveningen.” field-sizing: content lets the width follow the selected option instead. One line, exactly the kind of platform detail worth filing away.

• Lab01: Sebastiano Guerriero (the CodyHouse founder) runs this gallery of “best-in-class” UI experiments: a dozen small, polished interface studies you can open and inspect. Pure frontend inspiration; good to keep in the tab you open when a layout needs a spark.

• Saazio: A conversion-focused SaaS website template built on Next.js 16, React 19, Tailwind 4, TypeScript, and shadcn/ui, with the usual marketing pages ready to customize. It’s a sensible starting point if you’re standing up a product site and don’t want to design the hero for the hundredth time.

The post View Transitions pushed past the spec, modern CSS theming, sizing selects to their content, UI experiments, and a shadcn SaaS template appeared first on Cristian Nebunu.

• Yammi Audit Log: This one handles the audit problem most packages fumble: attribution once a change happens two queue hops from the request. A normal audit trail credits the queue worker; Yammi carries the original identity through the chain and stamps a correlation ID, so you can reconstruct a cascade that spans a controller, a queued job, and a scheduled command as one workflow. No traits or observers: it hooks Eloquent events globally, with opt-in mode, async writes, a tamper-evident hash chain, and GDPR tooling all sitting dormant until you switch them on. The one caveat: raw Query Builder writes aren’t captured. A thoughtful default for “who really did this.”

• Watchtower: One production dashboard for scheduled tasks, queues, jobs, and exceptions. The part I like is that you can act from it, too: run a task on demand, bulk-retry failed jobs by exception type or time window, mark errors resolved. It works with any driver (database, Redis, SQS), uses deferred writes and sampling to stay off the request path, and has Horizon/Telescope-style gate auth. Heads up: this is close in spirit to the Vigilance package I recommended last batch (both monitor queues/schedules/errors on any driver), so if you’ve already bookmarked Vigilance, treat this as the alternative to compare against rather than a second must-install.

• Improving Laravel Architecture With Expressive: Wendell Adriel’s post is the architecture read of the batch. The problem it names is real: the Eloquent model becomes the object passed everywhere (controllers, actions, jobs, policies), dragging query building, persistence, and casting into business logic that only wanted the data. Expressive keeps Eloquent as the persistence layer but converts models into fully typed objects at the boundary, so your payment action depends on customerId and totalCents (typed, can’t accidentally call ->delete() or trigger lazy loads) instead of the whole database model. There’s a generator and a sync command to keep the typed classes in step with the models. His rule of thumb is the right one: don’t use it for simple CRUD; reach for it where a workflow deserves a firmer boundary. Pairs well with the Sandi Metz piece over in the essays.

• Filament UI Plus: A paid community component pack that adds the polish Filament doesn’t ship (skeleton loaders for tables and stat widgets, an animated collapsible sidebar, sticky table actions, a Livewire loading bar, inline label prefixes). It’s built to be upgrade-safe, with 10 of 13 features needing zero view overrides.

• filament-mcp: Mattias Geniar’s package (his second appearance this batch) is a clever one: an MCP server that reads your existing resource forms and generates typed create_post/update_product tools, so an AI agent operates your panel through a typed contract instead of squinting at screenshots via browser automation. Everything is opt-in, deletes require explicit opt-in, and every call runs through the same tokens, gates, policies, and tenant scoping a human hits, plus an audit log that doubles as the clearest window I’ve seen into what an agent actually does over the wire.

The post Audit logs that survive queue hops, a queue/schedule dashboard, typed Eloquent objects, and Filament that an AI agent can drive appeared first on Cristian Nebunu.

• Fast Laravel Case Study: Jason McCreary’s case study is a proper walkthrough of making Laravel News itself faster with plain Cloudflare page caching. The interesting part is that Laravel News looks uncacheable (hourly content, rotating sponsor cards, a newsletter form), and he cached it anyway. Three refactors did it: converting every page from Livewire to Blade components (only the newsletter form actually needed reactivity, so the rest were shedding wire: state that broke when cached and 419’d), swapping dynamic segments like the sponsor banner to Alpine AJAX fragments that hydrate a cached shell, and purging via model events plus a piggybacked scheduled command for scheduled posts. Result: 15% → 60% cached, edge responses around 20ms. All of it is HTTP caching done systematically, with no paid services.

• Octane vs PHP-FPM: Mattias Geniar’s write-up is the counterpoint I wanted after last batch’s Octane-in-production piece. He moved a fleet of Oh Dear uptime-checker boxes from PHP-FPM to Octane on FrankenPHP, measured real traffic before and after, and moved every one of them back. The reason is clean: Octane’s whole trick is skipping the framework bootstrap per request, and for an I/O-bound workload (each request is a ~400ms outbound check), that bootstrap is a rounding error. Warm workers even pushed idle-box CPU up. The one real win was lower CPU peaks on busy boxes. His rule: Octane earns its keep on CPU-bound, framework-heavy requests served at high rates, not on anything dominated by waiting on the network. Measure your own workload instead of trusting the hello-world benchmark.

• LaraPlugins Performance Audit: A fellow Romanian, Daniel Petrica, turns his 3AM war story into 12 concrete fixes, all with real numbers. An 8GB VPS pinned at 90% memory, 12 Horizon supervisors with maxJobs: 0, and a weekly job that fired 50,000 Cloudflare purge jobs in one cycle. The fixes are the good kind of boring: cap maxJobs everywhere so workers recycle memory, a global scope to stop loading a fat packagist_metadata JSON column on every query, three indexes he’d simply forgotten, and, my favourite, collapsing 50,000 purge jobs into one self-rescheduling job that batches URLs through a Redis SADD set (which dedupes for free). His closing line lands: when monitoring goes noisy you either fix the cause or tune the alerts, and every day you tune the alerts you train yourself to ignore your own dashboard.

• concurrency, parallelism & async in Laravel 13 + Livewire 4: The Developer Awam piece reframes a class of slowness as an execution-strategy problem instead of a database one: the dashboard that calls three APIs in series, the export that blocks for ten seconds. It’s a member-only Medium story so I only read the framing in full, but the distinction it draws (concurrency vs parallelism vs async, and where each fits in a Laravel/Livewire request) is the right mental model, and Laravel’s own concurrency helpers plus queued/deferred work are the tools it points at. Worth it if you keep reaching for a queue when what you actually want is a parallel fan-out.

• 7 Tips to Improve Your ECS Config: Tomáš Votruba’s tips are a back-to-basics cleanup for anyone whose ecs.php has sprawled. His line (“if it’s longer than 15 lines, you’re probably doing it wrong”) is the whole ethos: prefer sets over listing individual rules, use withRootFiles() instead of naming stray files, and lean on the new levels to introduce a coding standard step by step (perfect for agent-driven per-rule PR trains on a legacy codebase). The final config he strives for is three lines of prepared sets plus paths. Feed it to your agent or learn it yourself; either way it’s a good spring clean.

The post Caching Laravel News with Cloudflare, when Octane isn’t worth it, 12 fixes that saved a server, and a leaner ECS config appeared first on Cristian Nebunu.

• Device Bound Session Credentials: Making Stolen Cookies Useless: Scott Helme explains DBSC, and the point lands hard: after all our progress on passwords, 2FA, and passkeys, the thing an attacker actually steals is still just a cookie. DBSC binds the session to a device-held private key, so a short-lived cookie has to be cryptographically refreshed by proving possession of that key, which a stolen cookie replayed from another machine can’t do. He walks the registration and one-step vs. two-step refresh flows, plus the privacy design (fresh key pair per session, cleared with site data). Given the security angle in my own work, this is a keeper.

• Open-Sourcing dbsc-php: a Server Library for Device Bound Session Credentials in PHP: The companion release: a ~700-line, zero-dependency, MIT-licensed PHP library (ES256 only) that encodes the hard-won corrections between “what the spec says” and “what Chrome actually does.” The wire-protocol notes in the README are the best part: registration is single-phase, refresh is two-phase, both the cookie value and challenge must rotate every refresh, and (the one that bit them in production) DBSC state must live in its own key space (Redis/table) keyed by session id, never inside a read-modify-written session blob, or a race silently clobbers the binding. Framework-agnostic by design.

• Replace Your CI With a Merge Queue: David Crawshaw’s argument is short and provocative: after-the-fact CI worked because humans break HEAD rarely and at human speed, but agents are always new to a codebase, regress things constantly, and by the time the “you broke CI” email lands, the agent’s context window is long gone. His fix is to run all tests in a merge queue (no slow daily-only suites), then hand agents a second command that runs the queue minus the merge, so they fix problems before inflicting them on anyone. It clarified something I’d felt but not named.

• How do you do continuous profiling / execution tracing? (r/golang): A Go community thread on continuous profiling and execution tracing in production: how people actually wire up low-overhead, always-on profiling and trace collection instead of one-off pprof runs. Useful as a survey of the current tooling and the trade-offs people are living with.

• Claude up front, Codex in the back: A fun proof-of-concept: use Claude Code purely as the orchestrator (the pleasant UI you argue with) and have it invoke Codex non-interactively for the heavy lifting, so you get Claude’s UX with Codex’s depth at minimal Claude token spend. The honest part is the caveats: the orchestration overhead is roughly flat (~5-7K tokens per round trip), so on a one-line change the wrapper costs more than the work, and stacking two prompt layers plus three sets of agent rules (CLAUDE.md / CODEX.md / AGENTS.md) makes failures hard to debug. Worth it only when the task is big.

The post DBSC, Merge Queues & Agent Coding: Where Dev Is Heading appeared first on Cristian Nebunu.

• Scrubbable Staggered Animation with CSS @function: Instead of thinking of a stagger as a pile of independently animation-delay-ed objects, this reframes the whole effect as one progress value you can drive from anything: keyframes, scroll, whatever. The author builds a “stagger formula” from first principles (clamp + lerp over a per-item offset) and ports it to the new CSS @function rule, with sibling-index(), if(), and custom easing on top. It’s math-heavy, but the payoff is a reusable stagger you can scrub, with no JavaScript. Chrome/Edge only for now, so treat it as forward-looking.

• Scroll-Driven, Scroll-Triggered, Scroll States, and View Transitions: Geoff Graham distinguishes four concepts I constantly mix up: scroll-driven animation tied to scroll position, scroll-triggered animation that runs after crossing a threshold, container-query scroll-state styling such as stuck: top, and same- or cross-document view transitions unrelated to scrolling. I will keep the compact summary table at the end.

• date-light: A zero-dependency, fully typed TypeScript date utility with 39 functions in roughly 2.18KB minzipped. It fits the common case where I need a few date helpers without adding a heavyweight dependency.

• Brightlight: a SaaS theme for Astro & Tailwind CSS: A polished Astro and Tailwind SaaS template with a warm palette, clean grid, and pages for landing, about, contact, authentication, blog, changelog, help, integrations, and team content. SEO, sitemap, RSS, and Fuse.js search are included. It also ships AGENTS.md, SKILLS.md, and Cursor rules for extending it with coding agents. It would make a credible marketing-site base without starting from a blank design.

The post Modern CSS in 2026: @function, Scroll Animations & Tiny Tools appeared first on Cristian Nebunu.