A master’s in operating AI.

Operating environment

Get your terminal, VS Code, and Claude Code installed, authenticated, and verified so you can start building a real project in under an hour.

CLAUDE.md: persistent context

Write a CLAUDE.md file that gives Claude Code persistent memory of your project, so every session starts already knowing your stack, your conventions, and your prohibitions without you repeating them.

Prompt Arsenal

Build a personal arsenal of reusable prompts —each one with explicit role, context, structure, and intent— that produce consistently high-quality work instead of lottery answers.

Git & GitHub for operators

Version your work with Git and GitHub so you can experiment, break things, and roll back without fear — using branches, atomic commits, and diffs to review every change the AI proposes.

Automations and deploy

Turn a manual script or task into a system that runs and publishes on its own — from automating a repetitive command to deploying your site automatically on every push and scheduling tasks that run without you.

ChatGPT → Claude migration

Move your work from ChatGPT to Claude Code by setting up a documented, versioned system — where context lives in CLAUDE.md and repo files instead of getting lost in chat threads, and where the AI acts on your real files instead of just conversing.

Verificación y testing

Build a reusable verification checklist and apply it to a real Claude Code change before publishing it, proving the change does what it says.

Sesiones largas y orquestación

Design a long-session protocol: detect context degradation, set up a handoff that restarts clean without losing state, and delegate a branch of work to a subagent. Deliver the protocol applied to a real session.

Modeling in Postgres

Model a Postgres schema with tables, keys, types, and relationships that reflect the real invariants of your domain and don't force you into painful migrations three weeks later.

RLS: the server holds authority

Write and verify Row Level Security policies so that a user can only read and write their own rows, understanding that the client-side gate is UX and RLS is the only real security in a static site.

Magic-link auth & sessions

Implement magic-link authentication with Supabase and handle the client-side session honestly: knowing what the session guarantees, what it doesn't, and why that doesn't weaken your RLS.

SECURITY DEFINER, RPC and triggers

Write SECURITY DEFINER functions, RPCs, and triggers that execute privileged logic in a controlled way, without opening privilege-escalation holes.

Local ↔ cloud sync

Design a local↔cloud sync where the state living in localStorage uploads to Postgres without losing data or creating duplicates, resolving conflicts deterministically.

Advisors, migrations and auditing

Operate the database with versioned changes via migrations and use Supabase's advisors as a continuous security linter that warns you about tables without RLS, functions without search_path, and other holes before they reach production.

Astro & Vite that load fast

Set up and understand an Astro site that generates static HTML per route and locale, plus a Vite SPA project, knowing exactly what JS reaches the browser and why it loads fast.

Components and design tokens

Build a coherent visual system with design tokens (CSS custom properties) and reusable components, instead of loose repeated CSS, so that a brand change is one line and not a hunt.

Multi-tenant & white-label

Design a real multi-tenant white-label product: a single codebase serving many clients with their own brand, data and configuration, using the Store seam pattern that isolates the UI from storage.

i18n: one galaxy in 6 languages

Architect internationalization for 6 languages without duplicating pages, understanding translation patterns, fallback, and why hrefs must be locale-aware.

Deploy: Cloudflare, domains, env

Take a site from localhost to a real URL on Cloudflare Pages with a custom domain and environment variables managed securely, distinguishing what env goes to the client and what never does.

From localStorage to backend

Migrate the data layer from localStorage to a backend (Supabase) without rewriting the application, leveraging the Store seam so the change is an implementation swap, not a refactor.

Read-only ingest & keyless edge

Build a read-only ingest edge that pulls public world data to disk without ever exposing a single credential, and that is structurally incapable of trading or moving money.

Price-regime classifier

Build a pure, deterministic price-regime classifier that labels the state of the market (trend, volatility, behavior, stress) without ever sizing or trading a position.

Market Memory: forecast + calibration

Build Market Memory: a ledger that locks in a falsifiable prediction BEFORE the outcome, resolves it against the realized return, and scores its own calibration (hit-rate, Brier, calibration by confidence and by regime).

Anti-fabrication by construction

Design the system to be structurally incapable of inventing data or edge: null controls, significance with multiple-comparison correction, out-of-sample evaluation, and an edge_demonstrated that is always False by default.

Capital invariant

Implement the capital invariant: a ledger where capital accumulates between sessions, only moves on REAL closes (realized P&L), and never resets — so that the number on screen always reflects closed results, not replays or paper gains.

Autopilot ticks & honest loops

Build autopilot loops that accumulate real learning between ticks — deterministic from disk, idempotent, Gate-closed — instead of generating noise or fake activity.

Radical minimalism

Audit a real screen and deliver a before/after where every element you removed is justified by a decision, not by taste.

Typography with intent

Build a pair of headlines that mix Inter sans with italic-serif spans (Cormorant) without the eye detecting the jump, and document the size correction that makes it work.

Studio voice

Write a real page copy deck (hero + three sections) in an anonymous studio voice that passes the "truth or marketing?" test: every sentence is either verifiable or deleted.

Translating while preserving meaning

Produce an EN/ES pair of a copy block where the Spanish says the same thing as the English—not the literal—and deliver the notes behind each meaning decision.

Color and depth

Document a color-and-depth system (glass, bands, color fields) as a set of reusable rules and tokens, with samples that prove it adds life without adding noise.

Secrets: public vs private

Decide, for any key or token in your projects, whether it can live in the client or must never leave the server — and build the decision tree that stops you from getting it wrong again.

Threat model of an SSG

Think like the attacker of a static site with an anon key: enumerate the real attack surface of an SSG + Supabase and understand why the only defense that counts is RLS, not the client.

Adversarial auditing

Audit adversarially: treat every security finding as a hypothesis you must refute before believing it, instead of accepting 'looks vulnerable' or 'looks safe' by inspection.

Incident response & rollback

Respond to a production incident with a cold procedure: detect, contain, roll back safely, and run a blameless post-mortem that closes the root cause.

Isolation between projects

Make several projects share a single Postgres database without one being able to read, write, or break another's data — multi-project and multi-tenant isolation enforced by the DB, not by convention.

Observabilidad y coste

Set up an observability panel and a budget with alerts for a live system (Astro on Cloudflare Pages + Supabase): define which logs and metrics to watch, what triggers an alert, and which usage and token-spend ceilings warn you BEFORE the surprise bill arrives.