Voodoo.js: breakthrough or a return to a simpler web?
A deep look at Voodoo.js: HTML-first without a build, JSX in markup, reactivity without a Virtual DOM, honest benchmarks, and why the idea matters more than speed in the AI-coding era.
Stuzhuk Lab — Chemistry of Code
Chemistry of Code
← All posts
Tag
architecture
All blog posts with this tag.
Inside Voodoo.js: how a custom interpreter brings plain HTML to life
Reverse engineering Voodoo.js: from the browser HTML parser’s DOM to a lexer, Pratt AST, tree-walking interpreter, Proxy effects, and direct node writes—without eval.
Voodoo.js: a runtime architecture without a compiler, Virtual DOM, or eval
A layer map of Voodoo.js: walker, scope, reactivity, the cost of skipping a build, bundle size, feature creep, and HTML as an artifact for AI coding.
Teaching a Neural Network to Read Handwritten Digits: From CNN to TrOCR
A practical path from single-digit classification to sequence recognition on real paper forms: CNN, CTC, CRNN, TrOCR, labels from your database, experiments, and a production pipeline without the wrong model.
Design Patterns (GoF): vocabulary, not a goal
GoF digest: patterns as named solutions, Strategy and Observer today, pattern fever trap, AI cargo-cult — with cases and actions for today.
ACL and multi-tenancy in RAG: filter permissions before retrieval, not after
Production RAG cannot leave authorization to the model. How to isolate tenants, apply access lists before retrieval, close hidden leak channels, and measure recall under tight filters.
RAG document ingestion: PDFs, tables, OCR, and versions without silent garbage
A production ingest pipeline for RAG: immutable originals, PDF and scan parsing, tables that keep their headers, parser quarantine, versioning, and idempotent replay.
The economics of data structures
There are no universally fast data structures. How to count storage, access, mutation, and movement costs — and pick a structure for the actual workload.
Lovable: 400 routes from Next.js to TanStack Start without a big bang
Proxy dual-run, #shared core, adapters, and agents: lovable.dev left Vercel for its own stack at 42M MAU.
How LLMs Find Knowledge: From Tokens and Transformers to RAG
How text becomes tokens and vectors, what a Transformer actually does, why training is not RAG, and how to grow a Markdown knowledge base into retrieval.
How LLMs Are Trained: Pretraining, Fine-Tuning, LoRA, RAG, and Agents
A practical map of LLM adaptation: what changes model weights, what plugs in knowledge and tools, and how to choose an approach without “fine-tuning on PDFs.”
Cheap LLMs for agents: why token savings raise task cost
Why distilled models spawn extra tool calls, how benchmarks mislead, and which metrics beat price-per-million for agent TCO.
Problem Engineering: specs beat prompt tricks for AI-generated code
Five-layer problem specs for AI coding: invariants, data contracts, concurrency, fault topology, and observability—before you prompt.
Language Model Quality Testing: What the Tests Are and What They Actually Measure
LLM quality checks: public task sets, arenas, model judges, safety, product regression, and online signals — what each test measures and what it cannot see.
Vector databases for AI agents in 2026: beyond raw ANN speed
Qdrant, Pinecone, Weaviate, pgvector, and Milvus compared for agent memory: filtering, hybrid search, tenancy, and quantization.
React Native in 2026: New Architecture, native code, and AI boundaries
A real-app walkthrough: Fabric and JSI, where work runs, bare vs Expo, keyboards on complex forms, and where AI actually helps in RN.
Spec-Driven Development in 2026: the spec as source of truth for AI-assisted coding
Make the specification the primary artifact: spec → plan → agent code → verify, 2026 tools, vs TDD/BDD, and where SDD breaks.
Vector databases in production: the index and storage layer for semantic search
How to run a vector database as an index layer: ANN algorithms, filters, tenancy, operations, and when pgvector beats a dedicated store.
Bun's Zig-to-Rust rewrite: 'never rewrite from scratch' was a frozen cost model
64 agents moved Bun's core in 11 days. The rewrite taboo was about cost, not metaphysics — and review debt did not disappear.
Why cheap testing gets expensive: the economics of software failure cost
A feature is an investment that does not end at release. How to account for build, verification, support, and failure cost — and why you should test in proportion to blast radius, not coverage percentage.
Best programming books for working engineers
Twelve software engineering books worth reading: selection criteria, who each is for, core ideas, and a forthcoming digest series on this blog.
AI Evaluation Harness in 2026: Golden Sets, Regression Gates, and Release Criteria That Survive Production
Build an AI evaluation harness that connects golden datasets, retrieval and generation metrics, CI regression gates, shadow traffic, release controls, observability, and LLM gateway FinOps.
AI Guardrails in 2026: Policy Gates, Tool Allowlists, and Safe Autonomy for Production Agents
A practical operating model for putting AI agents and RAG systems into production: policy-as-code, narrowly scoped tools, human approvals, adversarial testing, and audit evidence that engineers can actually use.
Failover playbooks: timeouts, circuit breakers, honest degradation
Build LLM failover playbooks with bounded retries and honest degraded modes.
LLM Gateway & FinOps in 2026: Model Routing, Token Budgets, and Cost Control Without Sacrificing Quality
A practical 2026 guide to LLM gateways and FinOps: request taxonomy, model routing, token budgets, caching caveats, failover, multi-provider contracts, chargeback, security, observability, and a 90-day rollout plan.
How to design a model routing taxonomy for product teams
Design stable model routes around workload contracts rather than provider labels.
Semantic caching without leaking tenant data
Build a multi-tenant semantic cache without cross-tenant exposure or stale authorization.
Token budgets and chargeback for multi-team AI platforms
Set token budgets and chargeback using useful-work metrics and clear ownership.
Production RAG Engineering in 2026: Chunking, Hybrid Search, Reranking, and Evals
A practical guide to production RAG architecture: ingestion, chunking, hybrid retrieval, reranking, evaluation, observability, security, and staged delivery for engineering teams.
Prompt Injection in Production 2026: Defending RAG, Tools, and Agents Against Untrusted Content
A production security model for prompt injection: treat retrieved documents, web pages, tool results, and MCP resources as hostile input; isolate context, constrain egress and tools, sandbox execution, and test layered defenses.
Chunking experiments for PDF, HTML, and knowledge bases
Run controlled chunking experiments while preserving document structure and citations.
How to build a golden dataset for RAG evaluation
Build a representative, versioned golden dataset for RAG retrieval and answer evaluation.
Hybrid search with BM25, vectors, and reciprocal-rank fusion
Combine BM25, vector retrieval, and reciprocal-rank fusion with measurable production guardrails.
Reranking in production RAG: quality, latency, and cost
Operate a RAG reranking stage with explicit quality, latency, and cost budgets.
From Junior to Senior Go Developer: What You Actually Need to Learn
A realistic Go growth map: the Junior foundation, Middle-level idioms and production work, then Senior architecture and responsibility—without needless frameworks or checklist theater.
MCP in production 2026: the stateless spec, security, and migration
A practical guide to Model Context Protocol after the 2026-07-28 release: no sessions, MRTR, header-based routing, auth hardening, shadow MCP, and servers that survive real load.
Enterprise RAG Architecture: From Search to a Knowledge Platform
How to design scalable RAG for many data sources, millions of documents, and access-controlled enterprise knowledge.
Designing an Enterprise AI Platform: From Pilot to Standard
How to design a scalable enterprise AI platform where knowledge, security, and integrations matter more than any individual model.
Arcovia maps architecture health in React and Next.js
Arcovia analyzes React and Next.js projects, maps dependencies, explains its architecture score, and highlights refactoring priorities.
Enterprise Assessment: Start an AI Project with Facts
How interviews, process analysis, and knowledge discovery prepare an enterprise AI project for sound design.
An Enterprise AI Architect’s First Day: Start with the Business
Why an enterprise AI project starts with business needs, knowledge, and security—not with a model or server choice.
The Future of Enterprise AI: Architecture That Lasts
How to build an enterprise AI platform that can outlive changing models, vendors, and data formats.
Where Code Generation Ends and Engineering Begins
AI already writes working functions, but a product is architecture, context, risk, and accountability. The boundary between code and engineering, a 15-year legacy case study, and developer skills in 2026.
Can AI Understand a Codebase With 15 Years of History?
Millions of lines, hundreds of tables, dozens of integrations: what AI grasps in hours, where it fails, how teams deploy RAG and repo indexing, and why expert + model beats either alone.
How the Modern Web Works: From Browser to Database
The full HTTP request journey — DNS, TLS, CDN, load balancer, Nginx, backend, Redis, queues, PostgreSQL, and back to the browser. A practical guide for developers and architects.
How to Design a Modern ERP System in 2026: From Monolith to Platform
Metadata Driven Architecture, platform engines, frontend stack, and migration strategy — how to build an ERP that evolves for decades without a rewrite every five years.
How to Design a System That Will Last 10 Years
Why systems die from early architectural decisions, not outdated tech — and how to design for change, not features: module boundaries, domain modeling, data, ADRs, and a decade-long checklist.
Why EAV Looks Like a Good Idea — Then Destroys ERP Performance
Entity–Attribute–Value looks perfect at the start: flexibility without migrations. Why JOINs, indexes, and reports break ERP years later — and where EAV fits, and where it does not.
The Most Expensive Mistake in ERP Architecture — Trying to Make the System Universal
Why the illusion of universality turns ERP into an EAV monster: lost performance, typing, and business meaning — and how to build around the domain, not abstract entities.
Evolution of Web Application Architecture Over the Last 20 Years
From server-side rendering in 2005 to AI apps and edge computing: how web architectures changed, why past choices were not mistakes, and how to pick an approach in 2026.
Why Most ERP Systems Turn Into Monolithic Monsters
The ERP success paradox: exceptions, technical debt, a single database, and the distributed monolith. Why the monster follows business growth and how to slow decay.