Posts

A skill deep-dive in the Harness series: write-acceptance-criteria, step five — the last — of the clarify authoring chain. How rubric.json and e2e-cases.json are built before any code exists: four layers laid in a fixed order, five item kinds, three coverage lines, why waivers must state their reasons, and why the gate may only be passed by sharpening items, never by lowering levels. Overview in “From ‘It Runs’ to Deliverable.”

A skill deep-dive in the Harness series: api-testing, the evaluation-side API probe. Why a page rendering correctly cannot prove the API is fine, why the contract must be checked from outside with real requests (success, every documented error, boundaries, permission denied, malformed input), what each case must record, how the probe log becomes evidence for judge items, and why a contract mismatch and a missing contract are two different verdicts. Overview in “From ‘It Runs’ to Deliverable.”

A skill deep-dive in the Harness series (bug-root-cause, general-purpose group). Why the fastest fix is almost always a patch over the symptom — a null check where the value shouldn't be null, a retry where the call shouldn't fail — and why the bug just returns in a different costume; how this standalone root-cause method walks a broken value back to where it was born in eight steps: reproduce, bisect, build an evidence chain, one-sentence cause, fix at the origin, check the blast radius, lock it with a test. Overview in “From ‘It Runs’ to Deliverable.”

Part one of the skill deep-dive series (clarify-requirements), the first link of the clarify chain. Why a vague request must not go straight to writing, why the interview covers all eleven modules in the first round, why the user's answers are recorded verbatim, and why not even a draft PRD may exist before confirmation — the why and the how. Overview in “From ‘It Runs’ to Deliverable.”

A Harness skill deep-dive (component-from-design), from the general-purpose group. Why AI implementations of a design are always 'close, but off everywhere,' why every spec value gets mapped to a token name before any code is written, why 'no raw hex or px in the new styles' is the acceptance test, and why a mockup shows one state while a component must survive all of them — the why and the how. Overview in “From ‘It Runs’ to Deliverable.”

A skill deep-dive (context-map, general-purpose group). Why an agent dropped into an unfamiliar repo fails from lack of a map, not lack of skill; what the map actually records — directory purposes, verified commands, sources of truth, high-risk zones, hard rules; and why the map must be pointers, not copies — traced rule by rule to the SKILL.md source. Overview in “From ‘It Runs’ to Deliverable.”

A Harness skill deep-dive: deterministic-eval, the evaluator's working discipline in the evaluation phase. The same feature, code untouched, scores 88 on Monday and 71 on Tuesday — what broke is not the code but the evaluation, which is itself a random variable. How this skill replaces judgement with measurement: fix the checklist first, run don't read, cite evidence for every pass, mark what can't run as not-verified, and report only, never fix on the side. Overview in “From ‘It Runs’ to Deliverable.”

A skill deep-dive in the Harness series: e2e-testing, the evaluation-side execution skill. The cases were authored before any code existed, by write-acceptance-criteria; this skill takes e2e-cases.json at evaluation time and walks every journey in a real browser: start the app, run the scripted cases, capture pages with harness capture and actually look at every screenshot, run at least three exploratory probes, and score the judge items with cited evidence. Why assertions must pin to what the user can see, why weakening a failing case is the same act as silencing the compiler, and why an environment that cannot run a browser makes the evaluation blocked rather than approximate. Overview in “From ‘It Runs’ to Deliverable.”

A skill deep-dive (fix-from-report, the developer-side remediation skill). Why fix rounds so easily make things worse; why the evaluation report is the complete work order and anything off-list is a new feature request; why the developer never sees the full rubric and never edits the report; why every fix starts with a reproduction and ends with one precise commit — traced rule by rule to the SKILL.md source. Overview in “From ‘It Runs’ to Deliverable.”

A Harness skill deep-dive: i18n-extract, a general-purpose skill. Sweep hardcoded user-visible strings out of components and behind keys, then verify completeness in both directions for every locale: why extraction must be a sweep and not a spot fix, why keys name meaning and place rather than wording, and why a key missing in one locale is a defect, not a TODO. Overview in “From ‘It Runs’ to Deliverable.”

A skill deep-dive (implement-task), the first of the implementation group. Why executing a task starts with a test that fails, why the declared scope is a permission rather than a suggestion, why drive-by refactors are a violation, and why an impossible task must stop and report instead of improvising — the why and the how. Overview in “From ‘It Runs’ to Deliverable.”

Part one of the general-purpose group in the Harness skill-by-skill series (plan-before-code). Why an AI that starts coding ten seconds after the request is where the disaster begins, why functional points must be written as input → action → validation → result instead of implementation tasks, and why every unknown has exactly two exits — ask, or write it down as an assumption. Overview in “From ‘It Runs’ to Deliverable.”

Part thirteen of the skill deep-dive series (ship-checklist), the first of the delivery pair. Why a feature that passes evaluation can still die on an unconfigured environment variable, why this checklist makes no judgments and only prevents omissions, what its seven steps actually check, and why “should be fine” is banned from the delivery note — the why and the how. Overview in “From ‘It Runs’ to Deliverable.”

A skill deep-dive (state-schema-first), from the general-purpose group. The state-layer post explained why the same fact must live in exactly one place; this one goes down into the working method itself: enumerate the facts before choosing any types, fill five columns per fact — field, type, initial value, whether it may be absent, source of truth — why the two most-skipped columns breed the bugs, and how the finished table gets diffed field by field by the scan. Overview in “From ‘It Runs’ to Deliverable.”

A skill deep-dive in the Harness series: sync-overview, the delivery-side skill that closes the loop. After a feature reaches done, it folds the product and technical changes that have actually settled into product.md and technical.md under .harness/overview/ — why deltas are registered during clarify but written only at delivery, why the overview has many readers and exactly one writer, what may never be written into it, and why even 'no change' gets a dated line. Overview in “From ‘It Runs’ to Deliverable.”

A skill deep-dive in the Harness series (systematic-debugging, the debugging discipline inside the Implement phase). Why an AI's default debugging move is patching, and how twenty minutes can stack up three fixes nobody can explain; how this skill turns debugging from guessing into experiment in seven steps — reliable reproduction, one hypothesis at a time, a failure you can switch on and off at will, and a root cause recorded in the task report — rule by rule against the SKILL.md text. Overview in “From ‘It Runs’ to Deliverable.”

Part five of the five-layer constraints series (the aesthetics layer), closing the five layers. Why a page can be wrong with every feature right; how visual regression actually runs (screenshots, baselines, pixel diffs); what each of the three UI deduction rules polices; why “what good looks like” must be written as anchors first; and the half that must be admitted — automation only measures half of it. Overview in “From ‘It Runs’ to Deliverable.”

Part one of the five-phase series (the Clarify phase), opening the phase block. How a one-line request becomes a locked contract: the planner interviews until open questions hit zero, then authors seven contract files in a fixed order; why the coverage gate blocks all code until coverage is complete; and why an existing PRD is imported, never rewritten. Overview in “From ‘It Runs’ to Deliverable.”

Part five of the Harness five-phase series (Deliver). Why the done state may only be set by the kernel, when evaluation passed, stable passes are met, and the delivery gate is green all at once; why the gate runs the project's own build, tests, and lint instead of inventing another set of checks; why the acceptance report must state what was never verified; how stable changes are folded into the project overview after done; and why Paused, the state entered when budgets run out, is more honest than a fake done — the why and the how. Overview in “From ‘It Runs’ to Deliverable.”

Part four of the five-layer constraints series (the engineering layer). Why import direction is law rather than convention, why import cycles are banned outright, why the point of a 300-line file cap is not the number itself, and why the checks sit on the only road to delivery — the why and the how. Overview in “From ‘It Runs’ to Deliverable.”

Part three of the five-phase series (Evaluate). Why a model grading its own code always ends in full marks, why evaluation needs an evaluator in a fresh context, how the rubric's three item types are scored, why essential and pitfall vetoes can't be saved by a high total, and why a report is never edited once written — the why and the how. Overview in “From ‘It Runs’ to Deliverable.”

Part two of the five-phase series (the Implement phase). Why the developer role never sees the rubric, why work proceeds one task at a time with one precise commit per task, and why the commit id it reports is verified by the kernel with git rev-parse — the why and the how. Overview in “From ‘It Runs’ to Deliverable.”

Part three of the five-layer constraints series (the state layer). Why state bugs pass the compiler and lint unseen, why every fact is listed before its schema is written (field, type, initial value, whether it may be absent, source of truth), why server data and client state live apart, and why persisted keys must be namespaced — the why and the how. Overview in “From ‘It Runs’ to Deliverable.”

Part two of the five-layer constraints series (the styling layer). Why AI-written pages each look fine alone but don't read as one product together; how design tokens shrink the option set until a wrong choice is impossible; and a quieter failure — an AI inventing token names that don't exist, while an undefined CSS variable fails in silence. Overview in “From ‘It Runs’ to Deliverable,” part one is “The Language Layer.”

Part four of the five-phase series (the Verify phase). Why one evaluation pass is not proof: Verify must be run by a different fresh evaluator context, all judge-item evidence is regenerated from scratch with stale evidence scoring zero automatically, and the feature must pass a configured number of consecutive times — the mechanical differences from Evaluate, and why each one exists. Overview in “From ‘It Runs’ to Deliverable”; previous part: the Evaluate phase.

Part twenty-one of the Harness skill deep-dives (verification-before-completion), closing the series. Why “all tests pass” can describe a version of the code that no longer exists, the skill's five-step gate, what explicitly does not count as evidence, and why this is the same rule as task SHA verification, evaluation evidence freshness, and Verify's stable passes — at four different scales. Overview in “From ‘It Runs’ to Deliverable.”

A skill deep-dive in the Harness series (write-dev-plan), step five of the clarify chain. Why a dev plan must be split into tasks small enough for one commit and verifiable on their own, why every task carries requirement ids and check commands, and why the plan is a file the kernel can reconcile against rather than a chat message — the why and the how. Overview in “From ‘It Runs’ to Deliverable.”

A skill deep-dive (write-prd, second in the clarify authoring chain). Why a requirements document can read flawlessly and still jam every downstream step; why REQ numbering is a contract, not formatting; why an imported PRD gets its gaps filled but never a word rewritten — traced rule by rule to the SKILL.md source. Overview in “From ‘It Runs’ to Deliverable.”

Part of the Harness skill deep-dive series (write-quality-vision, third link of the clarify chain). How a page passes every functional check and still feels wrong; why vision.md admits exactly three kinds of anchor (REF/ANTI/RL); what makes a quality item scoreable, and why “smooth” and “premium” don't qualify. Overview in “From ‘It Runs’ to Deliverable.”

One article per skill in the Harness series (write-tech-design, step four of the clarify authoring chain). The same feature gets built twice with two different architectures by two contexts — which line of code is wrong? None of them: nobody ever wrote the decision down. This skill produces tech-design.md and pages.json — stack, module boundaries, data flow, state ownership, decided once and recorded. Overview in “From ‘It Runs’ to Deliverable.”

Part one of the five-layer constraints series (the language layer). Why the first layer must be compile-time, what TypeScript strict mode actually pins down, why any and @ts-ignore are backdoors to be sealed, and why type checking belongs after every task — the why and the how. Overview in “From ‘It Runs’ to Deliverable.”

The previous post covered why AI-written code needs a scene where mistakes surface; this one describes how I built that scene: five layers of constraints, a five-phase state machine with three roles, an evaluation system that never lets the model grade its own work, and a kernel that runs long workflows on a file-based state machine. The system is open source (frontend-harness-cli), and every mechanism described here can be found in the repository.

a16z's 7th edition: 29 of the top 50 AI products by consumer spending don't appear on any traffic chart. Traffic is vanity, revenue is sanity — and the overlap between these lists is shockingly small.

What the csso 'Selector can't has classes from different scopes' error means, why it happens in webpack builds that pass usage scopes to csso, and the three ways to fix it.

Yes — ChatGPT is a solid free speaking partner for fluency practice, roleplay, and instant corrections. But it can't score your pronunciation, structure your learning, or force real output. Here's how to use it well and what to pair it with.

A 2026 comparison of AI coding tools — Cursor, Claude Code, GitHub Copilot, Windsurf and more — covering real costs, use cases, hidden fees, and ban risks.

A record of the complete process for using Codex by creating a new Apple ID, switching to the US region, buying a gift card, and subscribing to ChatGPT in the App Store.

A simple tested path for subscribing to ChatGPT Plus on Android through Google Play, using a US Google Play profile, a Visa card, and a US VPN node.

A practitioner's Codex CLI guide: install, AGENTS.md setup, permission boundaries, skills and subagents — plus the common mistakes I actually hit adopting it.

A practical 2026 comparison of Claude Code vs OpenAI Codex: setup, workflow, pricing model, cloud delegation, and who each tool is best for.

Google has announced the transition from Gemini CLI to Antigravity CLI, and relevant personal/free requests will stop being served starting June 18, 2026. This guide covers who is affected, how to migrate, and what to update.

Partial requests returning 502 errors led us to discover that TCP health checks cannot detect application-layer availability. Here's our complete investigation and fix.

This AI news digest covers OpenAI's Images 2.0 model release, SpaceX's strategic partnership with Cursor, Google Gemini Deep Research updates, Kimi K2.6's agent capabilities, and Meta's mandatory AI training tracking software controversy.

Step-by-step tutorial: How to subscribe to ChatGPT and Claude on US Apple Store, including top-up, tax-free address setup, and contacting support to remove purchase restrictions.

This AI digest covers Musk's roadmap defining Grok 5 as AGI, NSA's model supply chain controversy, Anthropic's Opus 4.7 major update, Tesla Bot structural evolution, and the latest AI developments.

This AI digest covers OpenAI Codex's evolution into an AI operator, Claude Opus 4.7 release and performance controversy, Google Gemma 4 26B availability, 1.58-bit ternary model Bonsai, NVIDIA Lyra 2.0, Tesla FSD v14.3.1, and more.

This AI digest covers Gemini's official Mac client, Gemini 3.1 Flash TTS, 1-bit quantized models, Cursor's interactive Canvas, NVIDIA Lyra 2.0 open source, Anthropic's explosive revenue growth, and more.

This AI digest covers the latest developments including OpenAI's GPT-5.4-Cyber for cybersecurity, Anthropic's Claude Opus 4.7, Google's Gemma 4 local reasoning, Midjourney V8.1, and Tesla's Optimus robots in production lines.

Interpreting Dan Koe's profound insights on money: Making money is a skill, and the real obstacle is your cognitive level about money. Five levels from survival to contribution will help you re-understand the relationship between money and life.

Build a three-layer knowledge pipeline (raw, notes, posts) with Git + Markdown + LLM, inspired by Karpathy's LLM Wiki method.

Core AI Agent concepts: Agent vs Copilot, single/multi-Agent architectures, MCP and SGP protocols, and implementation strategies.

AI programming guide for developers: tool selection by scenario, Cherry Studio design workflows, and prompt templates.

When code generation costs approach zero, the real scarcity is asking good questions. Notes on AI-era mindset shifts and career strategy.

Beginner's guide to selling on Pinduoduo: product selection, pricing, shipping, and pitfalls to avoid for profitability.

An actionable career adaptation framework for knowledge workers when AI boosts productivity 10x, based on industry reports and history.

within a container whose height is limited by 100vh, the margin-top property of a child element may cause unnecessary bottom spacing and scrollbars.

how i use Gemini CLI to Translate large amouts of text

Why CPU spikes to 100% when requests hang - two real production cases on timeouts and rate limiting

Node.js dependency injection explained with TypeScript metadata generation, reflection API, and framework implementation details.

In-depth algorithm analysis covering complexity, sorting, binary search, greedy, divide-and-conquer, backtracking, and dynamic programming.

Data structures fundamentals covering linear and non-linear structures, including trees, heaps, skip lists, and advanced data structures.

Data structures problem-solving guide with LeetCode examples covering arrays, stacks, binary search, trees, heaps, and graph algorithms.

Complete Cookie technology guide covering CookieStore API, SameSite protection, CSRF defense, and cross-domain strategies.

Implement Service Workers: caching strategies, update mechanisms, offline support, and edge cases in PWA development.

Admin/backend architecture solution based on ICE 3.0 with permission control and communication mechanisms.

Animation library guide covering Framer Motion and Anime.js with declarative animations, gestures, and practical examples.

Cross-platform development architecture with modular design, responsive layout, platform-specific builds, and dynamic capabilities.

CDN technical guide covering caching strategies, auto-optimization, acceleration methods, IVS architecture, and real-world case studies.

Frontend architecture guide covering business architecture, product design, and enterprise application principles.

Frontend engineering guide covering project structure, Lerna multi-package management, Babel, gray deployment, and best practices.

Frontend performance optimization covering key metrics (TTFB, FCP, LCP, CLS), optimization strategies, and analysis methods.

Complete i18n/l10n guide covering multi-language support, CLDR data usage, RTL layout handling, and frontend value considerations.

Complete Node.js development and operations guide covering architecture, stability, monitoring, and deployment strategies.

Container technology overview explaining Docker, resource management, and the evolution from physical machines to virtualization to containers.

Midway v6 to v8 upgrade troubleshooting guide covering common errors, configuration migration, and dependency issues.

Solve common React issues: form resets, closure pitfalls, infinite loops, Error Boundaries, and performance optimization patterns.

A complete Webpack guide: how loaders work, Webpack-Chain and chunk splitting, Externals, Module Federation, Tree Shaking, how Webpack compares with Rollup and Vite — plus causes and fixes for common errors like "webpackJsonp is not defined" and "Can't resolve 'fs'".

Node.js streams and network fundamentals covering TCP/UDP protocols, HTTP, HTTPS, and common communication protocols.

Frontend tracking with SPM parameters: source tracking, exposure positions, session identification, and cross-page analytics.

Multi-platform development with React Native, Flutter, Taro, and responsive design techniques for mobile optimization.

How to use pm2 for automated script-based application startup and deployment

Grid Layout; Animations: usage of animation, animation-play-state, :checked, transform; CSS writing guidelines and examples

Master NPM: ghost dependencies, pnpm comparison, TypeScript types, package.json fields, and dependency management best practices.

Essential JavaScript knowledge covering closures, prototypes, async patterns, DOM manipulation, and modern ES features.

React Server Components explained: zero-bundle components, server-client boundaries, and the future of React rendering.

React SSR deep dive: streaming server-side rendering, selective hydration, and performance optimization techniques.

What is the history of Concurrent Mode and what problems does it solve?

Understand React's design philosophy, the problems it solves, and why its component model matters for modern UI development.

Master React Suspense for async components, code-splitting, data fetching, and providing better UX with fallback UI patterns.

AI fundamentals: machine learning, embeddings, model training, prompt engineering, and practical guidance on using AI tools effectively.

Personal investment guide covering index funds, stock analysis, financial statements, investment psychology, and financial freedom.

Modern English learning with AI: practical strategies, speaking practice tips, and building confidence without expensive classes.

Complete SQL guide covering DDL, DML, DCL statements, common functions, and practical database operation examples.

React state management guide comparing Class vs Hooks patterns and solutions like Redux, MobX, and zustand.

Node.js stream technology from beginner to advanced, covering networking, RPC, WebSockets, and practical patterns.

How to become better from a technical person's perspective

Learn A/B testing principles including hypothesis testing, orthogonal experiments, traffic splitting, and data-driven decision strategies.

The greater the problem you can define, the greater the success you can achieve.

Unit testing setup with Mocha, TypeScript integration, code coverage with NYC, and testing best practices.

Guide to building workplace influence, navigating promotions, and developing core competencies for career growth.

Node.js operations guide covering service restart, multi-tenant deployment, HSF service calls, and log management.

Master SSR: server-side rendering, static generation, hydration, serverless deployment, and streaming for optimal performance.

Refine the growth model indicators for frontend engineers, gradually improving personal professional skills

Explore the essence of computers: digital encoding, binary systems, logic gates, and how hardware executes software instructions.

Paul Graham's essay on how to work hard -- finding the right field, sustained effort, and avoiding procrastination.

React Hooks evolution from class components, core hooks (useState, useEffect), and performance optimization strategies.

Node.js debugging guide with Chrome Inspector techniques, practical case studies, and NodeParty community insights.