IamK77

Agent-era skill suites for Claude Code: engineering, distributed, inquiry, quarry, surface, and atelier, gated by the checklist CLI

Ten gated, agent-era engineering skills as one suite — spanning the software lifecycle: requirements (groundwork), architecture (load-bearing), engineering process (flightline), testing (assay), deployment & operations (stationkeeping), maintenance & evolution (husbandry); plus four cross-cutting lenses: the feedback surface (gauge), code craft (plumb), and the security pair — shield (aegis) and spear (gungnir). A separate un-gated navigator, pilot, routes you to the right skill(s) for a task — or tells you when none is needed. Each gated skill is a multi-stage flow, tuned for a world where agents write much of the code. Installs every skill under the /engineering: prefix. Note: the gates are enforced by the `checklist` CLI, which installs separately — see the repository README.

Engineer distributed systems for correctness under partial failure — the realities a single-machine programmer (and an agent) gets wrong by default. First skill: holdfast, the distributed-correctness lens. Its one shift is the third state — a remote call can succeed, fail, or leave you not knowing which — and its complete eight-stage map is: frame · communication · ordering · replication · consensus · sharding · fault-tolerance · coordination. Note: the gates are enforced by the `checklist` CLI, which installs separately — see the repository README.

Do computational research that survives review — the agent-era methodology for going from a vague area to published results, for fields where you run experiments to publish (machine learning, combinatorial optimization, operations research, systems, scheduling). A pipeline of gated lenses for six research steps: prospect (find and prove a defensible gap — mine-don't-read, seven seams run in parallel, survive an adversarial 'prove it's already done' attack), crucible (design the method — race death-cause-orthogonal variants to death against pre-committed kills, measure the ceiling with an oracle ladder first, trap the agent's infeasible-solution bugs with an independent feasibility checker), ledger (design the experiments — write down what counts as evidence before you look, firewall exploration from confirmation, freeze the protocol before the run), forge (run the experiments — harden the method into production experiment code, run it idempotently with the agent as a read-only operator, regenerate every table and figure with one command), reckoning (analyze the results — audit before you read, prove WHY with mechanism probes, defend against the garden of forking paths, settle every claim to a verdict), and envoy (write, submit, and defend — string the already-built argument into a manuscript, choose the venue by fit, hold the agent to its red lines so every number traces to a run id, defend through rebuttal, and persist up the resubmission ladder). Across all six the agent is the means (parallel miner, prototyper, experiment operator, adversarial reviewer, manuscript polisher), never the oracle — you keep taste, spec, judgment, and the signature on the claims. Note: the gates are enforced by the `checklist` CLI, which installs separately — see the repository README.

Find and judge high-value open-source repositories — the agent-era methodology for getting from 'I need something' (or 'show me something interesting') to a repo you can actually trust, instead of searching by keyword and trusting the star count. Two gated lenses. forage (discovery) finds the few candidates worth your time in either mode finding actually happens in: TARGETED, where the agent fans out every search seam in parallel against a sharp need-spec; or SERENDIPITOUS, where it ranges the high-signal surfaces (Show HN, off-peak trending, topic corners, taste-feeds) and brings back the orthogonal finds, captured cheaply so none is lost — the one shift being that search-syntax mastery is commoditized, so your edge is the need-spec and the taste. touchstone (evaluation) judges a repo in minutes by scanning its dashboards, not its code: an agent over-trusts exactly the two signals easiest to fake — the star count and a polished README, which is what an abandoned project or an AI-generated star-farm wears best — so touchstone inverts the weighting toward the signals that can't be cheaply faked (commit substance, issue-response quality, bus factor, real downstream Used-by, tests and CI), runs an AI-slop / star-farm detector, scores three axes (alive · healthy · well-built), and calibrates the verdict to your use-context (a weekend tryout and a production dependency pass different bars). The agent is the means (the parallel miner, the wanderer, the dashboard reader, the adversary), never the judge — you keep the need-spec, the 'worth a look' verdict, and the calibration of what a score means for your risk. forage hands its shortlist to touchstone; touchstone hands deep-dive survivors to the engineering suite. Note: the gates are enforced by the `checklist` CLI, which installs separately — see the repository README.

Build modern frontends from 0 to 1 — the agent-era methodology for the one discipline whose correctness spec lives in a human nervous system, not a document, so taste is load-bearing and cannot be outsourced. A pipeline of eight gated lenses across the build lifecycle: bearings (before the first line — model the user's mind not the database, fix the boundaries and the source-of-truth one-way doors, write the perception contract where latency tiers become architecture, and set the objective function before the metrics dashboard exists to pull you), keel (the walking skeleton — pierce every integration seam with one real-but-trivial vertical slice, deployed, with a contract generated from one source so types can't drift), wellspring (state architecture, the heart — classify every piece of state into the one bucket that owns it, minimize the source of truth and derive the rest, model hard interactions as explicit state machines, and wire data along the dependency graph not the component tree), seaworthy (build the unhappy path first — the loading/error/empty/edge states ARE the product, maintain the user's illusion of direct manipulation against an async failing machine, with accessibility and a performance budget built in), livery (the visual system — every visual value is a token derived from a system, never an ad-hoc literal: an oklch color-and-light model with a dark path, a type-and-spacing scale, depth and form from a single light model, and motion that earns its place with purpose, physics, and a reduced path — taste decides, the system enforces), trials (correctness — test behavior not structure so the suite is a net not a straitjacket, spend the budget where frontend bugs cluster via the testing trophy, mock only the network with a contract-true mock), lookout (delivery and observability — shipping is the start of the conversation with reality, RUM as psychophysics encoded as numbers, and the pre-launch objective-function ethics gate, because A/B testing is a gradient-descent optimizer that discovers manipulation as a local optimum with no one designing it), and bulwark (1-to-N — fight entropy by making the architecture self-enforcing: boundaries fossilized into lint, wrong abstractions pruned, the design system a living artifact, a steady state with no exit). Across all eight the agent writes the code, but the leverage migrates to the membrane between machine and mind — which boundary, whose source of truth, what causal story forms in the user's head, and whose interest the optimizer serves — the calls the agent cannot make. A separate un-gated navigator, pilot, routes a frontend task to the right entry stage — most frontend work isn't greenfield — or out to a sibling suite (engineering, distributed, quarry) when the real need is general code craft, distributed correctness, or library choice. Installs every skill under the /surface: prefix. Note: the gates are enforced by the `checklist` CLI, which installs separately — see the repository README.

Design software interfaces to a premium bar — the agent-era methodology for the one discipline whose correctness spec lives in a human nervous system (so taste is load-bearing and cannot be outsourced) and whose unit of quality is a SYSTEM, not a pile of hand-picked values. A pipeline of eight gated lenses across the visual-design system: canon (the design-judgment spine — choose a non-default visual language and a surface archetype, set the quantified targets the other lenses inherit, keep the visual serving the user's job), color (a perceptual oklch palette as tokens — neutral ramp with a temperature, semantic roles, a dark ramp that is re-tuned not inverted, contrast verified at design time, colorblind-safe data-viz), type (a modular type scale + a spacing scale on one rhythm, the optical tells that separate pro from amateur, and text that survives every language — BiDi/RTL, CJK, locale), layout (composition as a decision — the grid and hierarchy, measure and spatial rhythm, designed empty/loading/error states and form visuals, robustness for reality's long tail), form (depth from one light model — layered shadows and a tokenized elevation scale, concentric radii, gradient/texture with a job and without banding), graphics (DOM-first, dropping to Canvas/WebGL/GPU only where the DOM can't go and always with a fallback, plus one icon system and a coherent imagery system), motion (every animation with a purpose and real physics — spring vs easing, gesture intent arbitration, a true reduced-motion path, compositor-only at 60fps), and systems (the design system as one source of truth — tokens that cross the CSS↔JS boundary without drift, a living component library, a design→code handoff that stays in sync). Across all eight the agent emits plausible-but-incoherent values and feels no wrongness — so each layer is a taste decision the human makes and the system enforces. A separate un-gated navigator, pilot, routes a design task to the right entry lens — most design work isn't greenfield — or out to a sibling suite (surface for the CSS mechanism / what-to-build / state / unhappy paths, engineering for code craft, quarry for a library). Installs every skill under the /atelier: prefix. Note: the gates are enforced by the `checklist` CLI, which installs separately — see the repository README.

Ten gated, agent-era engineering skills as one suite — spanning the software lifecycle: requirements (groundwork), architecture (load-bearing), engineering process (flightline), testing (assay), deployment & operations (stationkeeping), maintenance & evolution (husbandry); plus four cross-cutting lenses: the feedback surface (gauge), code craft (plumb), and the security pair — shield (aegis) and spear (gungnir). A separate un-gated navigator, pilot, routes you to the right skill(s) for a task — or tells you when none is needed. Each gated skill is a multi-stage flow, tuned for a world where agents write much of the code. Installs every skill under the /engineering: prefix. Note: the gates are enforced by the `checklist` CLI, which installs separately — see the repository README.

Ten gated, agent-era engineering skills as one suite — spanning the software lifecycle: requirements (groundwork), architecture (load-bearing), engineering process (flightline), testing (assay), deployment & operations (stationkeeping), maintenance & evolution (husbandry); plus four cross-cutting lenses: the feedback surface (gauge), code craft (plumb), and the security pair — shield (aegis) and spear (gungnir). A separate un-gated navigator, pilot, routes you to the right skill(s) for a task — or tells you when none is needed. Each gated skill is a multi-stage flow, tuned for a world where agents write much of the code. Installs every skill under the /engineering: prefix. Note: the gates are enforced by the `checklist` CLI, which installs separately — see the repository README.

Ten gated, agent-era engineering skills as one suite — spanning the software lifecycle: requirements (groundwork), architecture (load-bearing), engineering process (flightline), testing (assay), deployment & operations (stationkeeping), maintenance & evolution (husbandry); plus four cross-cutting lenses: the feedback surface (gauge), code craft (plumb), and the security pair — shield (aegis) and spear (gungnir). A separate un-gated navigator, pilot, routes you to the right skill(s) for a task — or tells you when none is needed. Each gated skill is a multi-stage flow, tuned for a world where agents write much of the code. Installs every skill under the /engineering: prefix. Note: the gates are enforced by the `checklist` CLI, which installs separately — see the repository README.

Ten gated, agent-era engineering skills as one suite — spanning the software lifecycle: requirements (groundwork), architecture (load-bearing), engineering process (flightline), testing (assay), deployment & operations (stationkeeping), maintenance & evolution (husbandry); plus four cross-cutting lenses: the feedback surface (gauge), code craft (plumb), and the security pair — shield (aegis) and spear (gungnir). A separate un-gated navigator, pilot, routes you to the right skill(s) for a task — or tells you when none is needed. Each gated skill is a multi-stage flow, tuned for a world where agents write much of the code. Installs every skill under the /engineering: prefix. Note: the gates are enforced by the `checklist` CLI, which installs separately — see the repository README.

Ten gated, agent-era engineering skills as one suite — spanning the software lifecycle: requirements (groundwork), architecture (load-bearing), engineering process (flightline), testing (assay), deployment & operations (stationkeeping), maintenance & evolution (husbandry); plus four cross-cutting lenses: the feedback surface (gauge), code craft (plumb), and the security pair — shield (aegis) and spear (gungnir). A separate un-gated navigator, pilot, routes you to the right skill(s) for a task — or tells you when none is needed. Each gated skill is a multi-stage flow, tuned for a world where agents write much of the code. Installs every skill under the /engineering: prefix. Note: the gates are enforced by the `checklist` CLI, which installs separately — see the repository README.

Ten gated, agent-era engineering skills as one suite — spanning the software lifecycle: requirements (groundwork), architecture (load-bearing), engineering process (flightline), testing (assay), deployment & operations (stationkeeping), maintenance & evolution (husbandry); plus four cross-cutting lenses: the feedback surface (gauge), code craft (plumb), and the security pair — shield (aegis) and spear (gungnir). A separate un-gated navigator, pilot, routes you to the right skill(s) for a task — or tells you when none is needed. Each gated skill is a multi-stage flow, tuned for a world where agents write much of the code. Installs every skill under the /engineering: prefix. Note: the gates are enforced by the `checklist` CLI, which installs separately — see the repository README.

Ten gated, agent-era engineering skills as one suite — spanning the software lifecycle: requirements (groundwork), architecture (load-bearing), engineering process (flightline), testing (assay), deployment & operations (stationkeeping), maintenance & evolution (husbandry); plus four cross-cutting lenses: the feedback surface (gauge), code craft (plumb), and the security pair — shield (aegis) and spear (gungnir). A separate un-gated navigator, pilot, routes you to the right skill(s) for a task — or tells you when none is needed. Each gated skill is a multi-stage flow, tuned for a world where agents write much of the code. Installs every skill under the /engineering: prefix. Note: the gates are enforced by the `checklist` CLI, which installs separately — see the repository README.

Ten gated, agent-era engineering skills as one suite — spanning the software lifecycle: requirements (groundwork), architecture (load-bearing), engineering process (flightline), testing (assay), deployment & operations (stationkeeping), maintenance & evolution (husbandry); plus four cross-cutting lenses: the feedback surface (gauge), code craft (plumb), and the security pair — shield (aegis) and spear (gungnir). A separate un-gated navigator, pilot, routes you to the right skill(s) for a task — or tells you when none is needed. Each gated skill is a multi-stage flow, tuned for a world where agents write much of the code. Installs every skill under the /engineering: prefix. Note: the gates are enforced by the `checklist` CLI, which installs separately — see the repository README.

Ten gated, agent-era engineering skills as one suite — spanning the software lifecycle: requirements (groundwork), architecture (load-bearing), engineering process (flightline), testing (assay), deployment & operations (stationkeeping), maintenance & evolution (husbandry); plus four cross-cutting lenses: the feedback surface (gauge), code craft (plumb), and the security pair — shield (aegis) and spear (gungnir). A separate un-gated navigator, pilot, routes you to the right skill(s) for a task — or tells you when none is needed. Each gated skill is a multi-stage flow, tuned for a world where agents write much of the code. Installs every skill under the /engineering: prefix. Note: the gates are enforced by the `checklist` CLI, which installs separately — see the repository README.

Ten gated, agent-era engineering skills as one suite — spanning the software lifecycle: requirements (groundwork), architecture (load-bearing), engineering process (flightline), testing (assay), deployment & operations (stationkeeping), maintenance & evolution (husbandry); plus four cross-cutting lenses: the feedback surface (gauge), code craft (plumb), and the security pair — shield (aegis) and spear (gungnir). A separate un-gated navigator, pilot, routes you to the right skill(s) for a task — or tells you when none is needed. Each gated skill is a multi-stage flow, tuned for a world where agents write much of the code. Installs every skill under the /engineering: prefix. Note: the gates are enforced by the `checklist` CLI, which installs separately — see the repository README.

Ten gated, agent-era engineering skills as one suite — spanning the software lifecycle: requirements (groundwork), architecture (load-bearing), engineering process (flightline), testing (assay), deployment & operations (stationkeeping), maintenance & evolution (husbandry); plus four cross-cutting lenses: the feedback surface (gauge), code craft (plumb), and the security pair — shield (aegis) and spear (gungnir). A separate un-gated navigator, pilot, routes you to the right skill(s) for a task — or tells you when none is needed. Each gated skill is a multi-stage flow, tuned for a world where agents write much of the code. Installs every skill under the /engineering: prefix. Note: the gates are enforced by the `checklist` CLI, which installs separately — see the repository README.

Engineer distributed systems for correctness under partial failure — the realities a single-machine programmer (and an agent) gets wrong by default. First skill: holdfast, the distributed-correctness lens. Its one shift is the third state — a remote call can succeed, fail, or leave you not knowing which — and its complete eight-stage map is: frame · communication · ordering · replication · consensus · sharding · fault-tolerance · coordination. Note: the gates are enforced by the `checklist` CLI, which installs separately — see the repository README.

Do computational research that survives review — the agent-era methodology for going from a vague area to published results, for fields where you run experiments to publish (machine learning, combinatorial optimization, operations research, systems, scheduling). A pipeline of gated lenses for six research steps: prospect (find and prove a defensible gap — mine-don't-read, seven seams run in parallel, survive an adversarial 'prove it's already done' attack), crucible (design the method — race death-cause-orthogonal variants to death against pre-committed kills, measure the ceiling with an oracle ladder first, trap the agent's infeasible-solution bugs with an independent feasibility checker), ledger (design the experiments — write down what counts as evidence before you look, firewall exploration from confirmation, freeze the protocol before the run), forge (run the experiments — harden the method into production experiment code, run it idempotently with the agent as a read-only operator, regenerate every table and figure with one command), reckoning (analyze the results — audit before you read, prove WHY with mechanism probes, defend against the garden of forking paths, settle every claim to a verdict), and envoy (write, submit, and defend — string the already-built argument into a manuscript, choose the venue by fit, hold the agent to its red lines so every number traces to a run id, defend through rebuttal, and persist up the resubmission ladder). Across all six the agent is the means (parallel miner, prototyper, experiment operator, adversarial reviewer, manuscript polisher), never the oracle — you keep taste, spec, judgment, and the signature on the claims. Note: the gates are enforced by the `checklist` CLI, which installs separately — see the repository README.

Do computational research that survives review — the agent-era methodology for going from a vague area to published results, for fields where you run experiments to publish (machine learning, combinatorial optimization, operations research, systems, scheduling). A pipeline of gated lenses for six research steps: prospect (find and prove a defensible gap — mine-don't-read, seven seams run in parallel, survive an adversarial 'prove it's already done' attack), crucible (design the method — race death-cause-orthogonal variants to death against pre-committed kills, measure the ceiling with an oracle ladder first, trap the agent's infeasible-solution bugs with an independent feasibility checker), ledger (design the experiments — write down what counts as evidence before you look, firewall exploration from confirmation, freeze the protocol before the run), forge (run the experiments — harden the method into production experiment code, run it idempotently with the agent as a read-only operator, regenerate every table and figure with one command), reckoning (analyze the results — audit before you read, prove WHY with mechanism probes, defend against the garden of forking paths, settle every claim to a verdict), and envoy (write, submit, and defend — string the already-built argument into a manuscript, choose the venue by fit, hold the agent to its red lines so every number traces to a run id, defend through rebuttal, and persist up the resubmission ladder). Across all six the agent is the means (parallel miner, prototyper, experiment operator, adversarial reviewer, manuscript polisher), never the oracle — you keep taste, spec, judgment, and the signature on the claims. Note: the gates are enforced by the `checklist` CLI, which installs separately — see the repository README.

Do computational research that survives review — the agent-era methodology for going from a vague area to published results, for fields where you run experiments to publish (machine learning, combinatorial optimization, operations research, systems, scheduling). A pipeline of gated lenses for six research steps: prospect (find and prove a defensible gap — mine-don't-read, seven seams run in parallel, survive an adversarial 'prove it's already done' attack), crucible (design the method — race death-cause-orthogonal variants to death against pre-committed kills, measure the ceiling with an oracle ladder first, trap the agent's infeasible-solution bugs with an independent feasibility checker), ledger (design the experiments — write down what counts as evidence before you look, firewall exploration from confirmation, freeze the protocol before the run), forge (run the experiments — harden the method into production experiment code, run it idempotently with the agent as a read-only operator, regenerate every table and figure with one command), reckoning (analyze the results — audit before you read, prove WHY with mechanism probes, defend against the garden of forking paths, settle every claim to a verdict), and envoy (write, submit, and defend — string the already-built argument into a manuscript, choose the venue by fit, hold the agent to its red lines so every number traces to a run id, defend through rebuttal, and persist up the resubmission ladder). Across all six the agent is the means (parallel miner, prototyper, experiment operator, adversarial reviewer, manuscript polisher), never the oracle — you keep taste, spec, judgment, and the signature on the claims. Note: the gates are enforced by the `checklist` CLI, which installs separately — see the repository README.

Do computational research that survives review — the agent-era methodology for going from a vague area to published results, for fields where you run experiments to publish (machine learning, combinatorial optimization, operations research, systems, scheduling). A pipeline of gated lenses for six research steps: prospect (find and prove a defensible gap — mine-don't-read, seven seams run in parallel, survive an adversarial 'prove it's already done' attack), crucible (design the method — race death-cause-orthogonal variants to death against pre-committed kills, measure the ceiling with an oracle ladder first, trap the agent's infeasible-solution bugs with an independent feasibility checker), ledger (design the experiments — write down what counts as evidence before you look, firewall exploration from confirmation, freeze the protocol before the run), forge (run the experiments — harden the method into production experiment code, run it idempotently with the agent as a read-only operator, regenerate every table and figure with one command), reckoning (analyze the results — audit before you read, prove WHY with mechanism probes, defend against the garden of forking paths, settle every claim to a verdict), and envoy (write, submit, and defend — string the already-built argument into a manuscript, choose the venue by fit, hold the agent to its red lines so every number traces to a run id, defend through rebuttal, and persist up the resubmission ladder). Across all six the agent is the means (parallel miner, prototyper, experiment operator, adversarial reviewer, manuscript polisher), never the oracle — you keep taste, spec, judgment, and the signature on the claims. Note: the gates are enforced by the `checklist` CLI, which installs separately — see the repository README.

Do computational research that survives review — the agent-era methodology for going from a vague area to published results, for fields where you run experiments to publish (machine learning, combinatorial optimization, operations research, systems, scheduling). A pipeline of gated lenses for six research steps: prospect (find and prove a defensible gap — mine-don't-read, seven seams run in parallel, survive an adversarial 'prove it's already done' attack), crucible (design the method — race death-cause-orthogonal variants to death against pre-committed kills, measure the ceiling with an oracle ladder first, trap the agent's infeasible-solution bugs with an independent feasibility checker), ledger (design the experiments — write down what counts as evidence before you look, firewall exploration from confirmation, freeze the protocol before the run), forge (run the experiments — harden the method into production experiment code, run it idempotently with the agent as a read-only operator, regenerate every table and figure with one command), reckoning (analyze the results — audit before you read, prove WHY with mechanism probes, defend against the garden of forking paths, settle every claim to a verdict), and envoy (write, submit, and defend — string the already-built argument into a manuscript, choose the venue by fit, hold the agent to its red lines so every number traces to a run id, defend through rebuttal, and persist up the resubmission ladder). Across all six the agent is the means (parallel miner, prototyper, experiment operator, adversarial reviewer, manuscript polisher), never the oracle — you keep taste, spec, judgment, and the signature on the claims. Note: the gates are enforced by the `checklist` CLI, which installs separately — see the repository README.

Do computational research that survives review — the agent-era methodology for going from a vague area to published results, for fields where you run experiments to publish (machine learning, combinatorial optimization, operations research, systems, scheduling). A pipeline of gated lenses for six research steps: prospect (find and prove a defensible gap — mine-don't-read, seven seams run in parallel, survive an adversarial 'prove it's already done' attack), crucible (design the method — race death-cause-orthogonal variants to death against pre-committed kills, measure the ceiling with an oracle ladder first, trap the agent's infeasible-solution bugs with an independent feasibility checker), ledger (design the experiments — write down what counts as evidence before you look, firewall exploration from confirmation, freeze the protocol before the run), forge (run the experiments — harden the method into production experiment code, run it idempotently with the agent as a read-only operator, regenerate every table and figure with one command), reckoning (analyze the results — audit before you read, prove WHY with mechanism probes, defend against the garden of forking paths, settle every claim to a verdict), and envoy (write, submit, and defend — string the already-built argument into a manuscript, choose the venue by fit, hold the agent to its red lines so every number traces to a run id, defend through rebuttal, and persist up the resubmission ladder). Across all six the agent is the means (parallel miner, prototyper, experiment operator, adversarial reviewer, manuscript polisher), never the oracle — you keep taste, spec, judgment, and the signature on the claims. Note: the gates are enforced by the `checklist` CLI, which installs separately — see the repository README.

Find and judge high-value open-source repositories — the agent-era methodology for getting from 'I need something' (or 'show me something interesting') to a repo you can actually trust, instead of searching by keyword and trusting the star count. Two gated lenses. forage (discovery) finds the few candidates worth your time in either mode finding actually happens in: TARGETED, where the agent fans out every search seam in parallel against a sharp need-spec; or SERENDIPITOUS, where it ranges the high-signal surfaces (Show HN, off-peak trending, topic corners, taste-feeds) and brings back the orthogonal finds, captured cheaply so none is lost — the one shift being that search-syntax mastery is commoditized, so your edge is the need-spec and the taste. touchstone (evaluation) judges a repo in minutes by scanning its dashboards, not its code: an agent over-trusts exactly the two signals easiest to fake — the star count and a polished README, which is what an abandoned project or an AI-generated star-farm wears best — so touchstone inverts the weighting toward the signals that can't be cheaply faked (commit substance, issue-response quality, bus factor, real downstream Used-by, tests and CI), runs an AI-slop / star-farm detector, scores three axes (alive · healthy · well-built), and calibrates the verdict to your use-context (a weekend tryout and a production dependency pass different bars). The agent is the means (the parallel miner, the wanderer, the dashboard reader, the adversary), never the judge — you keep the need-spec, the 'worth a look' verdict, and the calibration of what a score means for your risk. forage hands its shortlist to touchstone; touchstone hands deep-dive survivors to the engineering suite. Note: the gates are enforced by the `checklist` CLI, which installs separately — see the repository README.

Find and judge high-value open-source repositories — the agent-era methodology for getting from 'I need something' (or 'show me something interesting') to a repo you can actually trust, instead of searching by keyword and trusting the star count. Two gated lenses. forage (discovery) finds the few candidates worth your time in either mode finding actually happens in: TARGETED, where the agent fans out every search seam in parallel against a sharp need-spec; or SERENDIPITOUS, where it ranges the high-signal surfaces (Show HN, off-peak trending, topic corners, taste-feeds) and brings back the orthogonal finds, captured cheaply so none is lost — the one shift being that search-syntax mastery is commoditized, so your edge is the need-spec and the taste. touchstone (evaluation) judges a repo in minutes by scanning its dashboards, not its code: an agent over-trusts exactly the two signals easiest to fake — the star count and a polished README, which is what an abandoned project or an AI-generated star-farm wears best — so touchstone inverts the weighting toward the signals that can't be cheaply faked (commit substance, issue-response quality, bus factor, real downstream Used-by, tests and CI), runs an AI-slop / star-farm detector, scores three axes (alive · healthy · well-built), and calibrates the verdict to your use-context (a weekend tryout and a production dependency pass different bars). The agent is the means (the parallel miner, the wanderer, the dashboard reader, the adversary), never the judge — you keep the need-spec, the 'worth a look' verdict, and the calibration of what a score means for your risk. forage hands its shortlist to touchstone; touchstone hands deep-dive survivors to the engineering suite. Note: the gates are enforced by the `checklist` CLI, which installs separately — see the repository README.

Build modern frontends from 0 to 1 — the agent-era methodology for the one discipline whose correctness spec lives in a human nervous system, not a document, so taste is load-bearing and cannot be outsourced. A pipeline of eight gated lenses across the build lifecycle: bearings (before the first line — model the user's mind not the database, fix the boundaries and the source-of-truth one-way doors, write the perception contract where latency tiers become architecture, and set the objective function before the metrics dashboard exists to pull you), keel (the walking skeleton — pierce every integration seam with one real-but-trivial vertical slice, deployed, with a contract generated from one source so types can't drift), wellspring (state architecture, the heart — classify every piece of state into the one bucket that owns it, minimize the source of truth and derive the rest, model hard interactions as explicit state machines, and wire data along the dependency graph not the component tree), seaworthy (build the unhappy path first — the loading/error/empty/edge states ARE the product, maintain the user's illusion of direct manipulation against an async failing machine, with accessibility and a performance budget built in), livery (the visual system — every visual value is a token derived from a system, never an ad-hoc literal: an oklch color-and-light model with a dark path, a type-and-spacing scale, depth and form from a single light model, and motion that earns its place with purpose, physics, and a reduced path — taste decides, the system enforces), trials (correctness — test behavior not structure so the suite is a net not a straitjacket, spend the budget where frontend bugs cluster via the testing trophy, mock only the network with a contract-true mock), lookout (delivery and observability — shipping is the start of the conversation with reality, RUM as psychophysics encoded as numbers, and the pre-launch objective-function ethics gate, because A/B testing is a gradient-descent optimizer that discovers manipulation as a local optimum with no one designing it), and bulwark (1-to-N — fight entropy by making the architecture self-enforcing: boundaries fossilized into lint, wrong abstractions pruned, the design system a living artifact, a steady state with no exit). Across all eight the agent writes the code, but the leverage migrates to the membrane between machine and mind — which boundary, whose source of truth, what causal story forms in the user's head, and whose interest the optimizer serves — the calls the agent cannot make. A separate un-gated navigator, pilot, routes a frontend task to the right entry stage — most frontend work isn't greenfield — or out to a sibling suite (engineering, distributed, quarry) when the real need is general code craft, distributed correctness, or library choice. Installs every skill under the /surface: prefix. Note: the gates are enforced by the `checklist` CLI, which installs separately — see the repository README.

Build modern frontends from 0 to 1 — the agent-era methodology for the one discipline whose correctness spec lives in a human nervous system, not a document, so taste is load-bearing and cannot be outsourced. A pipeline of eight gated lenses across the build lifecycle: bearings (before the first line — model the user's mind not the database, fix the boundaries and the source-of-truth one-way doors, write the perception contract where latency tiers become architecture, and set the objective function before the metrics dashboard exists to pull you), keel (the walking skeleton — pierce every integration seam with one real-but-trivial vertical slice, deployed, with a contract generated from one source so types can't drift), wellspring (state architecture, the heart — classify every piece of state into the one bucket that owns it, minimize the source of truth and derive the rest, model hard interactions as explicit state machines, and wire data along the dependency graph not the component tree), seaworthy (build the unhappy path first — the loading/error/empty/edge states ARE the product, maintain the user's illusion of direct manipulation against an async failing machine, with accessibility and a performance budget built in), livery (the visual system — every visual value is a token derived from a system, never an ad-hoc literal: an oklch color-and-light model with a dark path, a type-and-spacing scale, depth and form from a single light model, and motion that earns its place with purpose, physics, and a reduced path — taste decides, the system enforces), trials (correctness — test behavior not structure so the suite is a net not a straitjacket, spend the budget where frontend bugs cluster via the testing trophy, mock only the network with a contract-true mock), lookout (delivery and observability — shipping is the start of the conversation with reality, RUM as psychophysics encoded as numbers, and the pre-launch objective-function ethics gate, because A/B testing is a gradient-descent optimizer that discovers manipulation as a local optimum with no one designing it), and bulwark (1-to-N — fight entropy by making the architecture self-enforcing: boundaries fossilized into lint, wrong abstractions pruned, the design system a living artifact, a steady state with no exit). Across all eight the agent writes the code, but the leverage migrates to the membrane between machine and mind — which boundary, whose source of truth, what causal story forms in the user's head, and whose interest the optimizer serves — the calls the agent cannot make. A separate un-gated navigator, pilot, routes a frontend task to the right entry stage — most frontend work isn't greenfield — or out to a sibling suite (engineering, distributed, quarry) when the real need is general code craft, distributed correctness, or library choice. Installs every skill under the /surface: prefix. Note: the gates are enforced by the `checklist` CLI, which installs separately — see the repository README.

Build modern frontends from 0 to 1 — the agent-era methodology for the one discipline whose correctness spec lives in a human nervous system, not a document, so taste is load-bearing and cannot be outsourced. A pipeline of eight gated lenses across the build lifecycle: bearings (before the first line — model the user's mind not the database, fix the boundaries and the source-of-truth one-way doors, write the perception contract where latency tiers become architecture, and set the objective function before the metrics dashboard exists to pull you), keel (the walking skeleton — pierce every integration seam with one real-but-trivial vertical slice, deployed, with a contract generated from one source so types can't drift), wellspring (state architecture, the heart — classify every piece of state into the one bucket that owns it, minimize the source of truth and derive the rest, model hard interactions as explicit state machines, and wire data along the dependency graph not the component tree), seaworthy (build the unhappy path first — the loading/error/empty/edge states ARE the product, maintain the user's illusion of direct manipulation against an async failing machine, with accessibility and a performance budget built in), livery (the visual system — every visual value is a token derived from a system, never an ad-hoc literal: an oklch color-and-light model with a dark path, a type-and-spacing scale, depth and form from a single light model, and motion that earns its place with purpose, physics, and a reduced path — taste decides, the system enforces), trials (correctness — test behavior not structure so the suite is a net not a straitjacket, spend the budget where frontend bugs cluster via the testing trophy, mock only the network with a contract-true mock), lookout (delivery and observability — shipping is the start of the conversation with reality, RUM as psychophysics encoded as numbers, and the pre-launch objective-function ethics gate, because A/B testing is a gradient-descent optimizer that discovers manipulation as a local optimum with no one designing it), and bulwark (1-to-N — fight entropy by making the architecture self-enforcing: boundaries fossilized into lint, wrong abstractions pruned, the design system a living artifact, a steady state with no exit). Across all eight the agent writes the code, but the leverage migrates to the membrane between machine and mind — which boundary, whose source of truth, what causal story forms in the user's head, and whose interest the optimizer serves — the calls the agent cannot make. A separate un-gated navigator, pilot, routes a frontend task to the right entry stage — most frontend work isn't greenfield — or out to a sibling suite (engineering, distributed, quarry) when the real need is general code craft, distributed correctness, or library choice. Installs every skill under the /surface: prefix. Note: the gates are enforced by the `checklist` CLI, which installs separately — see the repository README.

Build modern frontends from 0 to 1 — the agent-era methodology for the one discipline whose correctness spec lives in a human nervous system, not a document, so taste is load-bearing and cannot be outsourced. A pipeline of eight gated lenses across the build lifecycle: bearings (before the first line — model the user's mind not the database, fix the boundaries and the source-of-truth one-way doors, write the perception contract where latency tiers become architecture, and set the objective function before the metrics dashboard exists to pull you), keel (the walking skeleton — pierce every integration seam with one real-but-trivial vertical slice, deployed, with a contract generated from one source so types can't drift), wellspring (state architecture, the heart — classify every piece of state into the one bucket that owns it, minimize the source of truth and derive the rest, model hard interactions as explicit state machines, and wire data along the dependency graph not the component tree), seaworthy (build the unhappy path first — the loading/error/empty/edge states ARE the product, maintain the user's illusion of direct manipulation against an async failing machine, with accessibility and a performance budget built in), livery (the visual system — every visual value is a token derived from a system, never an ad-hoc literal: an oklch color-and-light model with a dark path, a type-and-spacing scale, depth and form from a single light model, and motion that earns its place with purpose, physics, and a reduced path — taste decides, the system enforces), trials (correctness — test behavior not structure so the suite is a net not a straitjacket, spend the budget where frontend bugs cluster via the testing trophy, mock only the network with a contract-true mock), lookout (delivery and observability — shipping is the start of the conversation with reality, RUM as psychophysics encoded as numbers, and the pre-launch objective-function ethics gate, because A/B testing is a gradient-descent optimizer that discovers manipulation as a local optimum with no one designing it), and bulwark (1-to-N — fight entropy by making the architecture self-enforcing: boundaries fossilized into lint, wrong abstractions pruned, the design system a living artifact, a steady state with no exit). Across all eight the agent writes the code, but the leverage migrates to the membrane between machine and mind — which boundary, whose source of truth, what causal story forms in the user's head, and whose interest the optimizer serves — the calls the agent cannot make. A separate un-gated navigator, pilot, routes a frontend task to the right entry stage — most frontend work isn't greenfield — or out to a sibling suite (engineering, distributed, quarry) when the real need is general code craft, distributed correctness, or library choice. Installs every skill under the /surface: prefix. Note: the gates are enforced by the `checklist` CLI, which installs separately — see the repository README.

Build modern frontends from 0 to 1 — the agent-era methodology for the one discipline whose correctness spec lives in a human nervous system, not a document, so taste is load-bearing and cannot be outsourced. A pipeline of eight gated lenses across the build lifecycle: bearings (before the first line — model the user's mind not the database, fix the boundaries and the source-of-truth one-way doors, write the perception contract where latency tiers become architecture, and set the objective function before the metrics dashboard exists to pull you), keel (the walking skeleton — pierce every integration seam with one real-but-trivial vertical slice, deployed, with a contract generated from one source so types can't drift), wellspring (state architecture, the heart — classify every piece of state into the one bucket that owns it, minimize the source of truth and derive the rest, model hard interactions as explicit state machines, and wire data along the dependency graph not the component tree), seaworthy (build the unhappy path first — the loading/error/empty/edge states ARE the product, maintain the user's illusion of direct manipulation against an async failing machine, with accessibility and a performance budget built in), livery (the visual system — every visual value is a token derived from a system, never an ad-hoc literal: an oklch color-and-light model with a dark path, a type-and-spacing scale, depth and form from a single light model, and motion that earns its place with purpose, physics, and a reduced path — taste decides, the system enforces), trials (correctness — test behavior not structure so the suite is a net not a straitjacket, spend the budget where frontend bugs cluster via the testing trophy, mock only the network with a contract-true mock), lookout (delivery and observability — shipping is the start of the conversation with reality, RUM as psychophysics encoded as numbers, and the pre-launch objective-function ethics gate, because A/B testing is a gradient-descent optimizer that discovers manipulation as a local optimum with no one designing it), and bulwark (1-to-N — fight entropy by making the architecture self-enforcing: boundaries fossilized into lint, wrong abstractions pruned, the design system a living artifact, a steady state with no exit). Across all eight the agent writes the code, but the leverage migrates to the membrane between machine and mind — which boundary, whose source of truth, what causal story forms in the user's head, and whose interest the optimizer serves — the calls the agent cannot make. A separate un-gated navigator, pilot, routes a frontend task to the right entry stage — most frontend work isn't greenfield — or out to a sibling suite (engineering, distributed, quarry) when the real need is general code craft, distributed correctness, or library choice. Installs every skill under the /surface: prefix. Note: the gates are enforced by the `checklist` CLI, which installs separately — see the repository README.

Build modern frontends from 0 to 1 — the agent-era methodology for the one discipline whose correctness spec lives in a human nervous system, not a document, so taste is load-bearing and cannot be outsourced. A pipeline of eight gated lenses across the build lifecycle: bearings (before the first line — model the user's mind not the database, fix the boundaries and the source-of-truth one-way doors, write the perception contract where latency tiers become architecture, and set the objective function before the metrics dashboard exists to pull you), keel (the walking skeleton — pierce every integration seam with one real-but-trivial vertical slice, deployed, with a contract generated from one source so types can't drift), wellspring (state architecture, the heart — classify every piece of state into the one bucket that owns it, minimize the source of truth and derive the rest, model hard interactions as explicit state machines, and wire data along the dependency graph not the component tree), seaworthy (build the unhappy path first — the loading/error/empty/edge states ARE the product, maintain the user's illusion of direct manipulation against an async failing machine, with accessibility and a performance budget built in), livery (the visual system — every visual value is a token derived from a system, never an ad-hoc literal: an oklch color-and-light model with a dark path, a type-and-spacing scale, depth and form from a single light model, and motion that earns its place with purpose, physics, and a reduced path — taste decides, the system enforces), trials (correctness — test behavior not structure so the suite is a net not a straitjacket, spend the budget where frontend bugs cluster via the testing trophy, mock only the network with a contract-true mock), lookout (delivery and observability — shipping is the start of the conversation with reality, RUM as psychophysics encoded as numbers, and the pre-launch objective-function ethics gate, because A/B testing is a gradient-descent optimizer that discovers manipulation as a local optimum with no one designing it), and bulwark (1-to-N — fight entropy by making the architecture self-enforcing: boundaries fossilized into lint, wrong abstractions pruned, the design system a living artifact, a steady state with no exit). Across all eight the agent writes the code, but the leverage migrates to the membrane between machine and mind — which boundary, whose source of truth, what causal story forms in the user's head, and whose interest the optimizer serves — the calls the agent cannot make. A separate un-gated navigator, pilot, routes a frontend task to the right entry stage — most frontend work isn't greenfield — or out to a sibling suite (engineering, distributed, quarry) when the real need is general code craft, distributed correctness, or library choice. Installs every skill under the /surface: prefix. Note: the gates are enforced by the `checklist` CLI, which installs separately — see the repository README.

Build modern frontends from 0 to 1 — the agent-era methodology for the one discipline whose correctness spec lives in a human nervous system, not a document, so taste is load-bearing and cannot be outsourced. A pipeline of eight gated lenses across the build lifecycle: bearings (before the first line — model the user's mind not the database, fix the boundaries and the source-of-truth one-way doors, write the perception contract where latency tiers become architecture, and set the objective function before the metrics dashboard exists to pull you), keel (the walking skeleton — pierce every integration seam with one real-but-trivial vertical slice, deployed, with a contract generated from one source so types can't drift), wellspring (state architecture, the heart — classify every piece of state into the one bucket that owns it, minimize the source of truth and derive the rest, model hard interactions as explicit state machines, and wire data along the dependency graph not the component tree), seaworthy (build the unhappy path first — the loading/error/empty/edge states ARE the product, maintain the user's illusion of direct manipulation against an async failing machine, with accessibility and a performance budget built in), livery (the visual system — every visual value is a token derived from a system, never an ad-hoc literal: an oklch color-and-light model with a dark path, a type-and-spacing scale, depth and form from a single light model, and motion that earns its place with purpose, physics, and a reduced path — taste decides, the system enforces), trials (correctness — test behavior not structure so the suite is a net not a straitjacket, spend the budget where frontend bugs cluster via the testing trophy, mock only the network with a contract-true mock), lookout (delivery and observability — shipping is the start of the conversation with reality, RUM as psychophysics encoded as numbers, and the pre-launch objective-function ethics gate, because A/B testing is a gradient-descent optimizer that discovers manipulation as a local optimum with no one designing it), and bulwark (1-to-N — fight entropy by making the architecture self-enforcing: boundaries fossilized into lint, wrong abstractions pruned, the design system a living artifact, a steady state with no exit). Across all eight the agent writes the code, but the leverage migrates to the membrane between machine and mind — which boundary, whose source of truth, what causal story forms in the user's head, and whose interest the optimizer serves — the calls the agent cannot make. A separate un-gated navigator, pilot, routes a frontend task to the right entry stage — most frontend work isn't greenfield — or out to a sibling suite (engineering, distributed, quarry) when the real need is general code craft, distributed correctness, or library choice. Installs every skill under the /surface: prefix. Note: the gates are enforced by the `checklist` CLI, which installs separately — see the repository README.

Build modern frontends from 0 to 1 — the agent-era methodology for the one discipline whose correctness spec lives in a human nervous system, not a document, so taste is load-bearing and cannot be outsourced. A pipeline of eight gated lenses across the build lifecycle: bearings (before the first line — model the user's mind not the database, fix the boundaries and the source-of-truth one-way doors, write the perception contract where latency tiers become architecture, and set the objective function before the metrics dashboard exists to pull you), keel (the walking skeleton — pierce every integration seam with one real-but-trivial vertical slice, deployed, with a contract generated from one source so types can't drift), wellspring (state architecture, the heart — classify every piece of state into the one bucket that owns it, minimize the source of truth and derive the rest, model hard interactions as explicit state machines, and wire data along the dependency graph not the component tree), seaworthy (build the unhappy path first — the loading/error/empty/edge states ARE the product, maintain the user's illusion of direct manipulation against an async failing machine, with accessibility and a performance budget built in), livery (the visual system — every visual value is a token derived from a system, never an ad-hoc literal: an oklch color-and-light model with a dark path, a type-and-spacing scale, depth and form from a single light model, and motion that earns its place with purpose, physics, and a reduced path — taste decides, the system enforces), trials (correctness — test behavior not structure so the suite is a net not a straitjacket, spend the budget where frontend bugs cluster via the testing trophy, mock only the network with a contract-true mock), lookout (delivery and observability — shipping is the start of the conversation with reality, RUM as psychophysics encoded as numbers, and the pre-launch objective-function ethics gate, because A/B testing is a gradient-descent optimizer that discovers manipulation as a local optimum with no one designing it), and bulwark (1-to-N — fight entropy by making the architecture self-enforcing: boundaries fossilized into lint, wrong abstractions pruned, the design system a living artifact, a steady state with no exit). Across all eight the agent writes the code, but the leverage migrates to the membrane between machine and mind — which boundary, whose source of truth, what causal story forms in the user's head, and whose interest the optimizer serves — the calls the agent cannot make. A separate un-gated navigator, pilot, routes a frontend task to the right entry stage — most frontend work isn't greenfield — or out to a sibling suite (engineering, distributed, quarry) when the real need is general code craft, distributed correctness, or library choice. Installs every skill under the /surface: prefix. Note: the gates are enforced by the `checklist` CLI, which installs separately — see the repository README.

Build modern frontends from 0 to 1 — the agent-era methodology for the one discipline whose correctness spec lives in a human nervous system, not a document, so taste is load-bearing and cannot be outsourced. A pipeline of eight gated lenses across the build lifecycle: bearings (before the first line — model the user's mind not the database, fix the boundaries and the source-of-truth one-way doors, write the perception contract where latency tiers become architecture, and set the objective function before the metrics dashboard exists to pull you), keel (the walking skeleton — pierce every integration seam with one real-but-trivial vertical slice, deployed, with a contract generated from one source so types can't drift), wellspring (state architecture, the heart — classify every piece of state into the one bucket that owns it, minimize the source of truth and derive the rest, model hard interactions as explicit state machines, and wire data along the dependency graph not the component tree), seaworthy (build the unhappy path first — the loading/error/empty/edge states ARE the product, maintain the user's illusion of direct manipulation against an async failing machine, with accessibility and a performance budget built in), livery (the visual system — every visual value is a token derived from a system, never an ad-hoc literal: an oklch color-and-light model with a dark path, a type-and-spacing scale, depth and form from a single light model, and motion that earns its place with purpose, physics, and a reduced path — taste decides, the system enforces), trials (correctness — test behavior not structure so the suite is a net not a straitjacket, spend the budget where frontend bugs cluster via the testing trophy, mock only the network with a contract-true mock), lookout (delivery and observability — shipping is the start of the conversation with reality, RUM as psychophysics encoded as numbers, and the pre-launch objective-function ethics gate, because A/B testing is a gradient-descent optimizer that discovers manipulation as a local optimum with no one designing it), and bulwark (1-to-N — fight entropy by making the architecture self-enforcing: boundaries fossilized into lint, wrong abstractions pruned, the design system a living artifact, a steady state with no exit). Across all eight the agent writes the code, but the leverage migrates to the membrane between machine and mind — which boundary, whose source of truth, what causal story forms in the user's head, and whose interest the optimizer serves — the calls the agent cannot make. A separate un-gated navigator, pilot, routes a frontend task to the right entry stage — most frontend work isn't greenfield — or out to a sibling suite (engineering, distributed, quarry) when the real need is general code craft, distributed correctness, or library choice. Installs every skill under the /surface: prefix. Note: the gates are enforced by the `checklist` CLI, which installs separately — see the repository README.

Design software interfaces to a premium bar — the agent-era methodology for the one discipline whose correctness spec lives in a human nervous system (so taste is load-bearing and cannot be outsourced) and whose unit of quality is a SYSTEM, not a pile of hand-picked values. A pipeline of eight gated lenses across the visual-design system: canon (the design-judgment spine — choose a non-default visual language and a surface archetype, set the quantified targets the other lenses inherit, keep the visual serving the user's job), color (a perceptual oklch palette as tokens — neutral ramp with a temperature, semantic roles, a dark ramp that is re-tuned not inverted, contrast verified at design time, colorblind-safe data-viz), type (a modular type scale + a spacing scale on one rhythm, the optical tells that separate pro from amateur, and text that survives every language — BiDi/RTL, CJK, locale), layout (composition as a decision — the grid and hierarchy, measure and spatial rhythm, designed empty/loading/error states and form visuals, robustness for reality's long tail), form (depth from one light model — layered shadows and a tokenized elevation scale, concentric radii, gradient/texture with a job and without banding), graphics (DOM-first, dropping to Canvas/WebGL/GPU only where the DOM can't go and always with a fallback, plus one icon system and a coherent imagery system), motion (every animation with a purpose and real physics — spring vs easing, gesture intent arbitration, a true reduced-motion path, compositor-only at 60fps), and systems (the design system as one source of truth — tokens that cross the CSS↔JS boundary without drift, a living component library, a design→code handoff that stays in sync). Across all eight the agent emits plausible-but-incoherent values and feels no wrongness — so each layer is a taste decision the human makes and the system enforces. A separate un-gated navigator, pilot, routes a design task to the right entry lens — most design work isn't greenfield — or out to a sibling suite (surface for the CSS mechanism / what-to-build / state / unhappy paths, engineering for code craft, quarry for a library). Installs every skill under the /atelier: prefix. Note: the gates are enforced by the `checklist` CLI, which installs separately — see the repository README.

Design software interfaces to a premium bar — the agent-era methodology for the one discipline whose correctness spec lives in a human nervous system (so taste is load-bearing and cannot be outsourced) and whose unit of quality is a SYSTEM, not a pile of hand-picked values. A pipeline of eight gated lenses across the visual-design system: canon (the design-judgment spine — choose a non-default visual language and a surface archetype, set the quantified targets the other lenses inherit, keep the visual serving the user's job), color (a perceptual oklch palette as tokens — neutral ramp with a temperature, semantic roles, a dark ramp that is re-tuned not inverted, contrast verified at design time, colorblind-safe data-viz), type (a modular type scale + a spacing scale on one rhythm, the optical tells that separate pro from amateur, and text that survives every language — BiDi/RTL, CJK, locale), layout (composition as a decision — the grid and hierarchy, measure and spatial rhythm, designed empty/loading/error states and form visuals, robustness for reality's long tail), form (depth from one light model — layered shadows and a tokenized elevation scale, concentric radii, gradient/texture with a job and without banding), graphics (DOM-first, dropping to Canvas/WebGL/GPU only where the DOM can't go and always with a fallback, plus one icon system and a coherent imagery system), motion (every animation with a purpose and real physics — spring vs easing, gesture intent arbitration, a true reduced-motion path, compositor-only at 60fps), and systems (the design system as one source of truth — tokens that cross the CSS↔JS boundary without drift, a living component library, a design→code handoff that stays in sync). Across all eight the agent emits plausible-but-incoherent values and feels no wrongness — so each layer is a taste decision the human makes and the system enforces. A separate un-gated navigator, pilot, routes a design task to the right entry lens — most design work isn't greenfield — or out to a sibling suite (surface for the CSS mechanism / what-to-build / state / unhappy paths, engineering for code craft, quarry for a library). Installs every skill under the /atelier: prefix. Note: the gates are enforced by the `checklist` CLI, which installs separately — see the repository README.

Design software interfaces to a premium bar — the agent-era methodology for the one discipline whose correctness spec lives in a human nervous system (so taste is load-bearing and cannot be outsourced) and whose unit of quality is a SYSTEM, not a pile of hand-picked values. A pipeline of eight gated lenses across the visual-design system: canon (the design-judgment spine — choose a non-default visual language and a surface archetype, set the quantified targets the other lenses inherit, keep the visual serving the user's job), color (a perceptual oklch palette as tokens — neutral ramp with a temperature, semantic roles, a dark ramp that is re-tuned not inverted, contrast verified at design time, colorblind-safe data-viz), type (a modular type scale + a spacing scale on one rhythm, the optical tells that separate pro from amateur, and text that survives every language — BiDi/RTL, CJK, locale), layout (composition as a decision — the grid and hierarchy, measure and spatial rhythm, designed empty/loading/error states and form visuals, robustness for reality's long tail), form (depth from one light model — layered shadows and a tokenized elevation scale, concentric radii, gradient/texture with a job and without banding), graphics (DOM-first, dropping to Canvas/WebGL/GPU only where the DOM can't go and always with a fallback, plus one icon system and a coherent imagery system), motion (every animation with a purpose and real physics — spring vs easing, gesture intent arbitration, a true reduced-motion path, compositor-only at 60fps), and systems (the design system as one source of truth — tokens that cross the CSS↔JS boundary without drift, a living component library, a design→code handoff that stays in sync). Across all eight the agent emits plausible-but-incoherent values and feels no wrongness — so each layer is a taste decision the human makes and the system enforces. A separate un-gated navigator, pilot, routes a design task to the right entry lens — most design work isn't greenfield — or out to a sibling suite (surface for the CSS mechanism / what-to-build / state / unhappy paths, engineering for code craft, quarry for a library). Installs every skill under the /atelier: prefix. Note: the gates are enforced by the `checklist` CLI, which installs separately — see the repository README.

Design software interfaces to a premium bar — the agent-era methodology for the one discipline whose correctness spec lives in a human nervous system (so taste is load-bearing and cannot be outsourced) and whose unit of quality is a SYSTEM, not a pile of hand-picked values. A pipeline of eight gated lenses across the visual-design system: canon (the design-judgment spine — choose a non-default visual language and a surface archetype, set the quantified targets the other lenses inherit, keep the visual serving the user's job), color (a perceptual oklch palette as tokens — neutral ramp with a temperature, semantic roles, a dark ramp that is re-tuned not inverted, contrast verified at design time, colorblind-safe data-viz), type (a modular type scale + a spacing scale on one rhythm, the optical tells that separate pro from amateur, and text that survives every language — BiDi/RTL, CJK, locale), layout (composition as a decision — the grid and hierarchy, measure and spatial rhythm, designed empty/loading/error states and form visuals, robustness for reality's long tail), form (depth from one light model — layered shadows and a tokenized elevation scale, concentric radii, gradient/texture with a job and without banding), graphics (DOM-first, dropping to Canvas/WebGL/GPU only where the DOM can't go and always with a fallback, plus one icon system and a coherent imagery system), motion (every animation with a purpose and real physics — spring vs easing, gesture intent arbitration, a true reduced-motion path, compositor-only at 60fps), and systems (the design system as one source of truth — tokens that cross the CSS↔JS boundary without drift, a living component library, a design→code handoff that stays in sync). Across all eight the agent emits plausible-but-incoherent values and feels no wrongness — so each layer is a taste decision the human makes and the system enforces. A separate un-gated navigator, pilot, routes a design task to the right entry lens — most design work isn't greenfield — or out to a sibling suite (surface for the CSS mechanism / what-to-build / state / unhappy paths, engineering for code craft, quarry for a library). Installs every skill under the /atelier: prefix. Note: the gates are enforced by the `checklist` CLI, which installs separately — see the repository README.

Design software interfaces to a premium bar — the agent-era methodology for the one discipline whose correctness spec lives in a human nervous system (so taste is load-bearing and cannot be outsourced) and whose unit of quality is a SYSTEM, not a pile of hand-picked values. A pipeline of eight gated lenses across the visual-design system: canon (the design-judgment spine — choose a non-default visual language and a surface archetype, set the quantified targets the other lenses inherit, keep the visual serving the user's job), color (a perceptual oklch palette as tokens — neutral ramp with a temperature, semantic roles, a dark ramp that is re-tuned not inverted, contrast verified at design time, colorblind-safe data-viz), type (a modular type scale + a spacing scale on one rhythm, the optical tells that separate pro from amateur, and text that survives every language — BiDi/RTL, CJK, locale), layout (composition as a decision — the grid and hierarchy, measure and spatial rhythm, designed empty/loading/error states and form visuals, robustness for reality's long tail), form (depth from one light model — layered shadows and a tokenized elevation scale, concentric radii, gradient/texture with a job and without banding), graphics (DOM-first, dropping to Canvas/WebGL/GPU only where the DOM can't go and always with a fallback, plus one icon system and a coherent imagery system), motion (every animation with a purpose and real physics — spring vs easing, gesture intent arbitration, a true reduced-motion path, compositor-only at 60fps), and systems (the design system as one source of truth — tokens that cross the CSS↔JS boundary without drift, a living component library, a design→code handoff that stays in sync). Across all eight the agent emits plausible-but-incoherent values and feels no wrongness — so each layer is a taste decision the human makes and the system enforces. A separate un-gated navigator, pilot, routes a design task to the right entry lens — most design work isn't greenfield — or out to a sibling suite (surface for the CSS mechanism / what-to-build / state / unhappy paths, engineering for code craft, quarry for a library). Installs every skill under the /atelier: prefix. Note: the gates are enforced by the `checklist` CLI, which installs separately — see the repository README.

Design software interfaces to a premium bar — the agent-era methodology for the one discipline whose correctness spec lives in a human nervous system (so taste is load-bearing and cannot be outsourced) and whose unit of quality is a SYSTEM, not a pile of hand-picked values. A pipeline of eight gated lenses across the visual-design system: canon (the design-judgment spine — choose a non-default visual language and a surface archetype, set the quantified targets the other lenses inherit, keep the visual serving the user's job), color (a perceptual oklch palette as tokens — neutral ramp with a temperature, semantic roles, a dark ramp that is re-tuned not inverted, contrast verified at design time, colorblind-safe data-viz), type (a modular type scale + a spacing scale on one rhythm, the optical tells that separate pro from amateur, and text that survives every language — BiDi/RTL, CJK, locale), layout (composition as a decision — the grid and hierarchy, measure and spatial rhythm, designed empty/loading/error states and form visuals, robustness for reality's long tail), form (depth from one light model — layered shadows and a tokenized elevation scale, concentric radii, gradient/texture with a job and without banding), graphics (DOM-first, dropping to Canvas/WebGL/GPU only where the DOM can't go and always with a fallback, plus one icon system and a coherent imagery system), motion (every animation with a purpose and real physics — spring vs easing, gesture intent arbitration, a true reduced-motion path, compositor-only at 60fps), and systems (the design system as one source of truth — tokens that cross the CSS↔JS boundary without drift, a living component library, a design→code handoff that stays in sync). Across all eight the agent emits plausible-but-incoherent values and feels no wrongness — so each layer is a taste decision the human makes and the system enforces. A separate un-gated navigator, pilot, routes a design task to the right entry lens — most design work isn't greenfield — or out to a sibling suite (surface for the CSS mechanism / what-to-build / state / unhappy paths, engineering for code craft, quarry for a library). Installs every skill under the /atelier: prefix. Note: the gates are enforced by the `checklist` CLI, which installs separately — see the repository README.

Design software interfaces to a premium bar — the agent-era methodology for the one discipline whose correctness spec lives in a human nervous system (so taste is load-bearing and cannot be outsourced) and whose unit of quality is a SYSTEM, not a pile of hand-picked values. A pipeline of eight gated lenses across the visual-design system: canon (the design-judgment spine — choose a non-default visual language and a surface archetype, set the quantified targets the other lenses inherit, keep the visual serving the user's job), color (a perceptual oklch palette as tokens — neutral ramp with a temperature, semantic roles, a dark ramp that is re-tuned not inverted, contrast verified at design time, colorblind-safe data-viz), type (a modular type scale + a spacing scale on one rhythm, the optical tells that separate pro from amateur, and text that survives every language — BiDi/RTL, CJK, locale), layout (composition as a decision — the grid and hierarchy, measure and spatial rhythm, designed empty/loading/error states and form visuals, robustness for reality's long tail), form (depth from one light model — layered shadows and a tokenized elevation scale, concentric radii, gradient/texture with a job and without banding), graphics (DOM-first, dropping to Canvas/WebGL/GPU only where the DOM can't go and always with a fallback, plus one icon system and a coherent imagery system), motion (every animation with a purpose and real physics — spring vs easing, gesture intent arbitration, a true reduced-motion path, compositor-only at 60fps), and systems (the design system as one source of truth — tokens that cross the CSS↔JS boundary without drift, a living component library, a design→code handoff that stays in sync). Across all eight the agent emits plausible-but-incoherent values and feels no wrongness — so each layer is a taste decision the human makes and the system enforces. A separate un-gated navigator, pilot, routes a design task to the right entry lens — most design work isn't greenfield — or out to a sibling suite (surface for the CSS mechanism / what-to-build / state / unhappy paths, engineering for code craft, quarry for a library). Installs every skill under the /atelier: prefix. Note: the gates are enforced by the `checklist` CLI, which installs separately — see the repository README.

Design software interfaces to a premium bar — the agent-era methodology for the one discipline whose correctness spec lives in a human nervous system (so taste is load-bearing and cannot be outsourced) and whose unit of quality is a SYSTEM, not a pile of hand-picked values. A pipeline of eight gated lenses across the visual-design system: canon (the design-judgment spine — choose a non-default visual language and a surface archetype, set the quantified targets the other lenses inherit, keep the visual serving the user's job), color (a perceptual oklch palette as tokens — neutral ramp with a temperature, semantic roles, a dark ramp that is re-tuned not inverted, contrast verified at design time, colorblind-safe data-viz), type (a modular type scale + a spacing scale on one rhythm, the optical tells that separate pro from amateur, and text that survives every language — BiDi/RTL, CJK, locale), layout (composition as a decision — the grid and hierarchy, measure and spatial rhythm, designed empty/loading/error states and form visuals, robustness for reality's long tail), form (depth from one light model — layered shadows and a tokenized elevation scale, concentric radii, gradient/texture with a job and without banding), graphics (DOM-first, dropping to Canvas/WebGL/GPU only where the DOM can't go and always with a fallback, plus one icon system and a coherent imagery system), motion (every animation with a purpose and real physics — spring vs easing, gesture intent arbitration, a true reduced-motion path, compositor-only at 60fps), and systems (the design system as one source of truth — tokens that cross the CSS↔JS boundary without drift, a living component library, a design→code handoff that stays in sync). Across all eight the agent emits plausible-but-incoherent values and feels no wrongness — so each layer is a taste decision the human makes and the system enforces. A separate un-gated navigator, pilot, routes a design task to the right entry lens — most design work isn't greenfield — or out to a sibling suite (surface for the CSS mechanism / what-to-build / state / unhappy paths, engineering for code craft, quarry for a library). Installs every skill under the /atelier: prefix. Note: the gates are enforced by the `checklist` CLI, which installs separately — see the repository README.

Design software interfaces to a premium bar — the agent-era methodology for the one discipline whose correctness spec lives in a human nervous system (so taste is load-bearing and cannot be outsourced) and whose unit of quality is a SYSTEM, not a pile of hand-picked values. A pipeline of eight gated lenses across the visual-design system: canon (the design-judgment spine — choose a non-default visual language and a surface archetype, set the quantified targets the other lenses inherit, keep the visual serving the user's job), color (a perceptual oklch palette as tokens — neutral ramp with a temperature, semantic roles, a dark ramp that is re-tuned not inverted, contrast verified at design time, colorblind-safe data-viz), type (a modular type scale + a spacing scale on one rhythm, the optical tells that separate pro from amateur, and text that survives every language — BiDi/RTL, CJK, locale), layout (composition as a decision — the grid and hierarchy, measure and spatial rhythm, designed empty/loading/error states and form visuals, robustness for reality's long tail), form (depth from one light model — layered shadows and a tokenized elevation scale, concentric radii, gradient/texture with a job and without banding), graphics (DOM-first, dropping to Canvas/WebGL/GPU only where the DOM can't go and always with a fallback, plus one icon system and a coherent imagery system), motion (every animation with a purpose and real physics — spring vs easing, gesture intent arbitration, a true reduced-motion path, compositor-only at 60fps), and systems (the design system as one source of truth — tokens that cross the CSS↔JS boundary without drift, a living component library, a design→code handoff that stays in sync). Across all eight the agent emits plausible-but-incoherent values and feels no wrongness — so each layer is a taste decision the human makes and the system enforces. A separate un-gated navigator, pilot, routes a design task to the right entry lens — most design work isn't greenfield — or out to a sibling suite (surface for the CSS mechanism / what-to-build / state / unhappy paths, engineering for code craft, quarry for a library). Installs every skill under the /atelier: prefix. Note: the gates are enforced by the `checklist` CLI, which installs separately — see the repository README.