Projects an employer can open and judge.

A publicly hosted product with its own domain or stable URL, plus a public repo: the orchestrator and worker agents, an MCP-based tool layer, a fast accessible web UI for submitting questions and reading results, CI/CD running lint/tests/build on every commit, persisted and inspectable run traces, a marketing landing page, a 10-slide pitch, a recorded demo video, and a README documenting the coordination design, the failure-recovery and scaling strategy, and three example end-to-end runs with their published reports.

• Submit-a-question interface accepting an open-ended technical or market question with a depth setting (quick scan vs deep dive).
• A lead orchestrator agent that decomposes the question into a research plan and spawns specialized worker agents.
• Specialized workers — web search, source reading, synthesis, and an independent fact-checker that verifies every claim.
• An MCP tool layer exposing search, fetch, and document tools so the same tools are reusable across agents and projects.
• Live run view: a real-time graph of agent activity, sub-questions in flight, and sources being consumed.
• Inline-cited report output where every claim links to the exact retrieved passage that supports it.
• Export to PDF, Markdown, and a shareable public report URL.
• Persisted, replayable run traces with token spend and latency per agent for cost auditing.
• Automatic worker-failure detection and re-dispatch so a crashed worker never aborts a run.
• A workspace history of past research runs with search and one-click re-run.
• Concurrency controls and per-run budget caps so many users can run research in parallel safely.

• The orchestrator decomposes a question and coordinates at least three specialized worker agents through explicit shared state.
• Tools are exposed through a standard protocol (MCP), not bespoke per-agent glue.
• The system is deployed to real public hosting with CI/CD on every commit and production observability (logs, traces, metrics).
• The architecture handles concurrent research runs under load, and a worker failure mid-run still yields a complete, correct deliverable.
• The web UI is fast, WCAG 2.2 AA accessible, and usable by a non-technical analyst without instruction.
• Every claim in the output report is traceable to a retrieved source, and run traces are persisted and inspectable.
• The project ships complete marketing: a landing page, a 10-slide pitch, and a recorded demo, presentable as a real product.
• The product is publicly reachable and fully reproducible from the repo by a stranger.

A fully functioning coding agent CLI and backend that takes a GitHub issue, spawns a planning tree with selectable thinking effort, executes code in a gVisor/Wasm sandbox, runs a compiler-driven verification loop, and submits a verified PR without human-in-the-loop 'vibe coding'.

• Compiler-directed feedback loops
• Selectable thinking effort
• Intermediate reasoning verifier

• Agent successfully explores multi-turn code changes and uses compiler feedback to self-correct
• Execution environment is properly sandboxed via gVisor or WebAssembly with strict resource boundaries
• Thinking-effort scaling tier is programmatically selectable, balancing token budget against search depth

A publicly hosted inference service with a stable URL and a clean playground UI, plus a public repo: the batching scheduler and KV-cache manager, an autoscaling deployment, CI/CD on every commit, production observability dashboards, a load-test harness, a benchmark report comparing static versus continuous batching across concurrency levels, a marketing landing page, a 10-slide pitch, a recorded demo, and a README explaining the memory, scheduling, and scaling design.

• An OpenAI-compatible HTTP API (chat/completions, streaming) so the service is a drop-in for existing clients.
• A paged KV-cache manager that eliminates memory fragmentation and supports prefix sharing across requests.
• Iteration-level continuous batching so new requests join the running batch without waiting for it to drain.
• A request scheduler with configurable priority and a tunable time-to-first-token versus throughput policy.
• Token-level response streaming over server-sent events or WebSocket.
• A clean playground UI to send prompts, watch streaming output, and see live latency and throughput.
• A live metrics dashboard: tokens-per-second, time-to-first-token, queue depth, GPU memory, and KV-cache utilization.
• Autoscaling across replicas driven by queue depth, with health and readiness probes.
• A built-in load-test harness that sweeps concurrency and emits a static-vs-continuous-batching benchmark report.
• API-key authentication and per-key rate limiting on the endpoint.
• Graceful degradation and request shedding when the GPU is saturated, instead of timeouts.

• The server implements paged KV-cache management and iteration-level continuous batching.
• A request scheduler is present and its time-to-first-token versus throughput tradeoff is documented.
• The service is deployed publicly with a clean playground UI, CI/CD on every commit, and autoscaling across replicas.
• Production observability tracks tokens-per-second and latency percentiles, and the endpoint is secured.
• A load-test report shows throughput and latency percentiles across concurrency levels, with continuous batching measurably compared against a static-batching baseline.
• GPU memory usage and KV-cache fragmentation are reported with the design that controls them.
• The project ships complete marketing — a landing page, a 10-slide pitch, and a recorded demo.
• The service is publicly reachable and reproducible, with a clear benchmark methodology.

An optimized mlx_lm or local inference server cluster achieving high tokens-per-second, utilizing 4-bit quantized layers, speculative drafting, and local node orchestration.

• 4-bit quantization
• Speculative decoding
• Local RDMA clustering

• Model quantized to 4-bit representation with minimal loss in perplexity
• Multi-node local cluster handles speculative decoding correctly across Thunderbolt 5 RDMA/local interfaces
• Inference server matches or exceeds baseline CPU-only token throughput by 10x

A publicly hosted product with a stable URL and a hyper-usable demo UI, plus a public repo and a published model card: the data pipeline, the QLoRA training configuration and run logs, an autoscaling serving deployment, CI/CD on every commit, production observability, an evaluation comparing base versus fine-tuned on a held-out set, a marketing landing page, a 10-slide pitch, a recorded demo, and a README documenting data sourcing, the contamination check, the scaling design, and the cost of the run.

• A dataset builder that ingests raw domain documents and turns them into cleaned, deduplicated instruction data.
• An automatic train/eval contamination check that flags and removes overlap before training.
• A LoRA/QLoRA training workflow with a reproducible config file and full run logging.
• An experiment view comparing runs across hyperparameters, with loss curves and eval scores.
• A held-out evaluation harness reporting target-task accuracy for the base model versus the fine-tuned model.
• A catastrophic-forgetting check that scores the fine-tuned model on general tasks, not just the target task.
• Adapter management: deploy one base model and hot-swap LoRA adapters per request.
• An OpenAI-compatible serving API for the fine-tuned model, with autoscaling.
• A hyper-usable demo UI where a domain user can try the specialist model on real prompts.
• An auto-generated model card documenting data sourcing, intended use, limitations, and run cost.
• Production observability and a secured, rate-limited endpoint.

• A training dataset is built, cleaned, and deduplicated, with sourcing documented.
• Parameter-efficient fine-tuning (LoRA or QLoRA) is run with a reproducible configuration.
• A held-out evaluation shows a measured improvement of the fine-tuned model over the base, with train/eval contamination explicitly checked and catastrophic forgetting measured.
• The fine-tuned model is served behind a real public API with a hyper-usable demo UI, autoscaling, CI/CD on every commit, observability, and a secured endpoint.
• The serving architecture holds under concurrent load and the scaling design is documented.
• The project ships complete marketing — a landing page, a 10-slide pitch, and a recorded demo.
• The repo is reproducible, a model card documents intended use and limitations, and the product is publicly reachable.

A publicly hosted product with a stable URL and a hyper-usable demo UI, plus a public repo and a published student model: the distillation data pipeline, the student training and preference-optimization configuration, an autoscaling serving deployment, CI/CD on every commit, production observability, a benchmark comparing teacher, student, and base on the target task, a cost-and-latency comparison, a marketing landing page, a 10-slide pitch, a recorded demo, and a README on the distillation method and scaling design.

• A teacher-labeling pipeline that uses a frontier model to generate or label distillation data for a chosen task.
• Synthetic-data generation with quality filtering so the student trains on clean, diverse examples.
• A student-training workflow producing a small (0.6B-8B) model, with reproducible configs and run logs.
• Optional preference optimization (DPO) to align the student where the task needs it.
• A three-way benchmark — teacher, student, and base — reporting capability retained on the target task.
• A cost-and-latency comparison computing the serving-cost reduction versus the teacher.
• An accuracy-floor gate that blocks shipping a student that drops below a configured retention threshold.
• An OpenAI-compatible serving API for the student model with autoscaling and scale-to-zero.
• A hyper-usable demo UI letting a buyer try teacher and student side by side on real prompts.
• An auto-generated model card with the distillation method, retention numbers, and intended use.
• Production observability and a secured, rate-limited endpoint.

• A teacher model is used to generate or label distillation data with a documented method.
• A smaller student is trained and the capability retained on the target task is measured against the teacher.
• Preference optimization (DPO or RLHF) or alignment of the student is applied where appropriate and justified.
• The student is served behind a real public API with a hyper-usable demo UI, autoscaling, CI/CD on every commit, observability, and a secured endpoint that holds under concurrent load.
• A cost and latency comparison shows the student is materially cheaper to serve, with the accuracy-versus-cost tradeoff reported honestly.
• The project ships complete marketing — a landing page, a 10-slide pitch, and a recorded demo.
• The repo is reproducible, the student model is published with a model card, and the product is publicly reachable.

A dockerized, query-active vector service and structured context database with live tracing and a production CI/CD evaluation gate.

• Contextual retrieval
• Automated EDDOps trace evaluations
• Continuous integration regression gates

• Vector retrieval latency is under 50ms at scale with structured indices
• EDD regression test suite executes automatically on mock context drift
• LLM-as-a-judge correctly rates context relevance and faithfulness with >85% alignment to human golden labels

A publicly hosted product with a stable URL and a hyper-usable security dashboard, plus a public repo: the tracing and observability pipeline, the automated red-team attack suite with a results report, the guardrails it validates, CI/CD on every commit, a marketing landing page, a 10-slide pitch, a recorded demo, and a README documenting the threat model, the drift-detection method, and the scaling design.

• An SDK/proxy that traces every LLM call with token counts, cost, latency, model, and a correlation ID.
• A real-time dashboard of spend, latency percentiles, error rate, and call volume, sliceable by feature and model.
• Silent-quality-drift detection that scores live traffic and alerts when output quality degrades.
• An automated red-team suite running prompt-injection, jailbreak, indirect-injection, and data-exfiltration attack batteries.
• A continuously updated attack library so new jailbreak techniques are tested as they emerge.
• Input and output guardrails (PII redaction, injection filtering, policy checks) with a report of which held under attack.
• A red-team scorecard mapping every finding to the OWASP LLM Top 10, exportable for audit.
• Alerting integrations (email, webhook, Slack) for cost spikes, drift, and failed guardrails.
• A high-throughput ingestion path that absorbs production call volume without sampling loss.
• Scheduled red-team runs in CI so a regression in defenses fails the build.
• Multi-project workspaces with role-based access so security leads and engineers see scoped views.

• Every LLM call is traced with token, cost, and latency telemetry and correlation IDs.
• Silent quality drift is detected and surfaced, not just raw metrics displayed.
• An automated red-team suite runs prompt-injection, jailbreak, and exfiltration attacks, and the report shows which input/output guardrails held and which failed.
• The platform is deployed to real public hosting with CI/CD on every commit and is itself secured.
• The ingestion path is hyperscalable and absorbs high call volume; the scaling design is documented.
• The dashboard is fast, WCAG 2.2 AA accessible, and readable at a glance by a security lead.
• The threat model is documented and mapped to the OWASP LLM Top 10.
• The project ships complete marketing — a landing page, a 10-slide pitch, and a recorded demo — and is publicly reachable and reproducible.

A public repo, a benchmark report, and a publicly hosted product with a stable URL and a hyper-usable demo UI serving the trained model: the distributed training configuration, the parallelism strategy, the checkpoint-and-resume logic, a live training-metrics dashboard, an autoscaling serving deployment, CI/CD on every commit, production observability, a scaling report across GPU counts, a marketing landing page, a 10-slide pitch, a recorded demo, and a README documenting the communication pattern, the failure-recovery design, and the serving-scale design.

• A job launcher that takes a model and dataset and spreads training across multiple GPUs from a simple config.
• Data parallelism plus at least one model-parallel strategy (tensor, pipeline, or fully-sharded).
• Gang scheduling so every worker in a job starts together, preventing partial scheduling that idles GPUs.
• Periodic distributed checkpointing with clean resume after a simulated node failure, losing no completed steps.
• A live training dashboard: loss curves, throughput, GPU utilization, and inter-node communication overhead.
• A scaling report that sweeps GPU counts and reports throughput and parallel efficiency.
• Automatic detection and recovery from a stalled or crashed worker mid-run.
• Spot/preemptible-instance support with checkpoint-driven recovery to cut training cost.
• Serving of the trained model behind an OpenAI-compatible API with autoscaling.
• A hyper-usable demo UI where a user can try the trained model on real prompts.
• Production observability and a secured, rate-limited serving endpoint.

• Training runs across multiple GPUs using data plus at least one model-parallel strategy, with correct collective communication and the parallelism decomposition documented.
• Checkpointing is implemented and the run resumes correctly after a simulated node failure.
• A scaling report shows throughput and efficiency across GPU counts, and communication-versus-computation overhead is measured and discussed.
• The trained model is served as a directly deployable product behind a real public API with a hyper-usable demo UI, autoscaling, CI/CD on every commit, observability, and a secured endpoint.
• A live training-metrics dashboard is provided, and the serving layer holds under concurrent load.
• The project ships complete marketing — a landing page, a 10-slide pitch, and a recorded demo.
• The repo is reproducible with a clear benchmark methodology and the product is publicly reachable.

A publicly hosted platform with a stable URL and a hyper-usable real-time dashboard plus query UI, plus a public repo: the streaming ingestion and inference pipeline, the at-scale vector index, the autoscaling and backpressure design, CI/CD on every commit, fleet observability, a load-and-failure test report, a marketing landing page, a 10-slide pitch, a recorded demo, and a README documenting delivery semantics, fault tolerance, security, and capacity planning.

• Ingestion of a high-rate live event stream (transactions, clicks, logs) from a streaming log such as Kafka.
• Per-event low-latency inference with a documented end-to-end latency budget (target sub-100ms).
• Stated delivery semantics — exactly-once, or at-least-once with idempotent processing — enforced in the pipeline.
• A feature layer that assembles per-event features within the latency window for the model.
• Inference results indexed into a vector store serving real-time similarity and nearest-neighbor queries.
• Backpressure and autoscaling that keep the platform healthy through a sudden traffic burst.
• Node-failure recovery with graceful degradation, demonstrated via injected failure.
• A real-time dashboard of event throughput, inference latency percentiles, and fleet health.
• A query UI for similarity search and recent-event lookup, usable without instruction.
• Alerting on latency-SLO breaches, lag buildup, and anomalous event rates.
• Multi-tenant isolation and a secured, rate-limited query API.

• A live event stream is consumed and inference runs per event with measured low latency.
• Delivery semantics (exactly-once or at-least-once with idempotency) are stated and justified.
• Inference results are indexed into a vector store that serves real-time similarity queries.
• Backpressure and autoscaling keep the platform healthy under a simulated traffic burst, and an injected node failure is recovered with graceful degradation.
• The platform is deployed to real public hosting with CI/CD on every commit, fleet observability, and security hardening.
• A fast, WCAG 2.2 AA accessible real-time dashboard and query UI lets a stranger use the platform without instruction.
• The project ships complete marketing — a landing page, a 10-slide pitch, and a recorded demo.
• The platform is publicly reachable and fully reproducible from the repo.

A publicly hosted visual-assistant product with a stable URL and a fast, accessible image-upload-and-chat UI, plus a public repo and a published model card: the image-text dataset pipeline, the LoRA/QLoRA fine-tuning configuration and run logs, an autoscaling serving deployment, CI/CD on every commit, production observability, an evaluation comparing the base versus fine-tuned VLM on a held-out set including a hallucination measurement, a marketing landing page, a 10-slide pitch, a recorded demo, and a README documenting the architecture, data sourcing, and scaling design.

• Image upload supporting documents, charts, screenshots, and photos, with a chat thread per image.
• A fine-tuned open-weight vision-language model adapted to a chosen domain with LoRA or QLoRA.
• A domain dataset builder that turns raw images and annotations into cleaned image-text training pairs.
• Grounded answers that reference regions or content of the uploaded image, with an explicit decline when the image cannot support the question.
• A held-out evaluation harness reporting target-task accuracy for the base versus the fine-tuned model.
• A visual-hallucination check that scores how often the model asserts content not present in the image.
• An OpenAI-compatible multimodal serving API so the assistant is a drop-in for existing clients.
• A fast, accessible chat UI with streaming answers, image thumbnails, and conversation history.
• A cost-and-latency dashboard tracking image-token usage and per-request timing.
• Autoscaling with health and readiness probes, and a secured, rate-limited endpoint.
• An auto-generated model card documenting data sourcing, intended use, and measured limitations.

• A domain image-text dataset is built, cleaned, and documented, with a train/eval split that is contamination-checked.
• A base open-weight VLM is fine-tuned with a parameter-efficient method (LoRA or QLoRA) using a reproducible configuration.
• A held-out evaluation shows a measured improvement of the fine-tuned VLM over the base model, and visual hallucination is measured and reported honestly.
• The VLM is served behind a real public API with a fast, WCAG 2.2 AA accessible image-upload-and-chat UI, autoscaling, CI/CD on every commit, observability, and a secured endpoint.
• Answers are grounded in the uploaded image, and the assistant declines or flags questions the image cannot support instead of fabricating.
• The project ships complete marketing — a landing page, a 10-slide pitch, and a recorded demo.
• The repo is reproducible, a model card documents intended use and limitations, and the product is publicly reachable.

A publicly hosted generative image studio with a stable URL and a hyper-usable creative UI, plus a public repo: the diffusion generation and editing pipeline, an autoscaling generation queue, content-safety filtering, CI/CD on every commit, production observability, a quality-and-latency report across guidance and step settings, a marketing landing page, a 10-slide pitch, a recorded demo, and a README documenting the conditioning design, the safety design, and the scaling design.

• Text-to-image generation with a latent diffusion model and tunable classifier-free guidance.
• Image-to-image and inpainting so a user can edit and refine an uploaded or generated image.
• A prompt workspace with generation history, versioning, and one-click re-run of a past generation.
• An autoscaling generation queue that accepts bursts of jobs and reports position and estimated wait.
• Content-safety filtering on prompts and outputs, with a documented policy and a clear refusal path.
• A quality-and-latency panel comparing step count and guidance settings on real prompts.
• A creative UI with live previews, thumbnails, and a gallery of past generations.
• Negative prompts and seed control so a creator can reproduce or steer a result deterministically.
• Export to common image formats and a shareable public gallery URL.
• A cost-and-throughput dashboard tracking generations, queue depth, and per-image compute.
• Autoscaling with health and readiness probes and a secured, rate-limited generation API.

• A latent diffusion pipeline generates images from text prompts with classifier-free guidance, and the guidance-versus-quality tradeoff is documented.
• Controllable editing is implemented — at least inpainting and image-to-image — and works on user-supplied images.
• The studio runs on an autoscaling generation queue that absorbs bursts without dropping jobs, and the scaling design is documented.
• Content-safety filtering screens prompts and outputs, and the policy and its enforcement are documented.
• The product is deployed to real public hosting with CI/CD on every commit, production observability of generation latency and queue depth, and a secured endpoint.
• The creative UI is fast, WCAG 2.2 AA accessible, and usable by a non-technical creator without instruction.
• The project ships complete marketing — a landing page, a 10-slide pitch, and a recorded demo — and is publicly reachable and reproducible.

A publicly hosted interpretability tool with a stable URL and a fast, accessible model-inspector UI, plus a public repo: the activation-capture and analysis backend, attention and activation visualizations, an activation-patching workflow, a sparse-autoencoder feature view, CI/CD on every commit, production observability, a marketing landing page, a 10-slide pitch, a recorded demo, and a README documenting the interpretability methods, their limitations, and the scaling design.

• Load a small open-weight transformer and run an arbitrary prompt through an instrumented forward pass.
• Attention-pattern visualization per head and per layer, with token-to-token attribution.
• Per-layer residual-stream and activation inspection, with the ability to compare two prompts side by side.
• An activation-patching workflow that swaps activations between runs to make causal claims about components.
• A sparse-autoencoder feature view that surfaces interpretable features and shows where they activate.
• Logit-lens style projection so a user can see how a prediction forms across layers.
• A saved-investigation workspace so a researcher can revisit and share a prior analysis.
• A fast, accessible inspector UI with clear, labelled visualizations and keyboard navigation.
• Concurrent-session support so multiple users can run analyses without contention.
• Production observability for analysis latency and session load, and a secured, rate-limited backend.
• A documentation panel stating, for each method, what it can and cannot tell you.

• A small open-weight transformer is loaded and instrumented, and per-layer activations and attention patterns are captured for an arbitrary prompt.
• An activation-patching workflow lets a user make a causal claim about which component drives a behavior, with the method documented.
• A sparse-autoencoder or probe-based feature view surfaces interpretable features from the residual stream, with honest limitations stated.
• The tool is deployed to real public hosting with a fast, WCAG 2.2 AA accessible inspector UI, CI/CD on every commit, production observability, and a secured endpoint.
• The analysis backend handles concurrent inspection sessions and the scaling design is documented.
• The project ships complete marketing — a landing page, a 10-slide pitch, and a recorded demo.
• The tool is publicly reachable and fully reproducible from the repo, and a researcher can use it without instruction.

A publicly hosted product with a stable URL and a hyper-usable safety-and-governance dashboard, plus a public repo: the safety-evaluation pipeline with capability, propensity, honesty, and red-team batteries, the auto-generated model card and risk-classification layer, CI/CD on every commit, production observability, a marketing landing page, a 10-slide pitch, a recorded demo, and a README documenting the evaluation methodology, the governance mapping, and the scaling design.

• A safety-evaluation runner with capability, propensity, honesty, and sycophancy batteries against a target model.
• An adversarial red-team suite covering jailbreaks, prompt injection, and indirect injection, with a continuously updated attack library.
• Structured, reproducible scoring so the same evaluation can be re-run and compared across model versions.
• An auto-generated, audit-ready model card capturing intended use, evaluation results, and limitations.
• A risk-classification layer that maps results to the NIST AI RMF Govern-Map-Measure-Manage functions and the EU AI Act risk tiers.
• A benchmark-overfitting check that runs novel held-out prompts alongside public benchmarks to expose inflated scores.
• A safety dashboard showing per-category results, risk status, and trend across evaluation runs.
• CI integration so a safety regression in a new model version fails the release gate.
• Exportable compliance reports suitable for an internal audit or external review.
• Role-based access so safety engineers, compliance leads, and reviewers see scoped views.
• Production observability and a secured, rate-limited evaluation API.

• A safety-evaluation pipeline runs capability, propensity, honesty, and adversarial red-team batteries against a target model and produces structured, reproducible scores.
• The red-team battery includes jailbreaks, prompt injection, and indirect injection, and the report shows which behaviors held and which failed.
• An auto-generated model card documents intended use, evaluation results, and limitations in an audit-ready format.
• A risk-classification layer maps the model and its results to the NIST AI RMF functions and the EU AI Act risk tiers, with the mapping justified.
• The platform is deployed to real public hosting with CI/CD on every commit, production observability, and a secured endpoint, and the evaluation path is hyperscalable under load.
• A fast, WCAG 2.2 AA accessible dashboard lets a safety or compliance lead read results and risk status at a glance.
• The project ships complete marketing — a landing page, a 10-slide pitch, and a recorded demo — and is publicly reachable and reproducible.

A publicly hosted portfolio product with a stable URL and a polished, fast, accessible UI, plus a public repo: the portfolio site, deep writeups of a curated set of AI projects each with a live demo link and real metrics, CI/CD on every commit, observability, security headers, a README documenting the build and design decisions, and a short pitch of the portfolio itself as a product.

• A landing view that communicates who the builder is and the strongest project within seconds.
• A curated set of deep project pages, each with a live demo link, a public repo, and an honest writeup.
• Real metrics on each project — usage, performance, or evaluation numbers — presented without inflation.
• A fast, accessible, responsive UI with semantic HTML, keyboard navigation, and security headers.
• CI/CD that rebuilds and redeploys the portfolio on every commit.
• An honest limitations section per project, so the portfolio reads as credible rather than marketed.
• A contact and links section that makes it frictionless for a recruiter to reach out.
• Lightweight observability or analytics so the builder sees how the portfolio performs.
• A documented build so the portfolio itself doubles as a reproducible engineering artifact.

• The portfolio presents a curated, small set of deep AI projects, each with a live demo, a public repo, an honest writeup, and real metrics.
• The site is deployed to real public hosting with CI/CD on every commit, observability, and security headers on every response.
• The UI is fast, WCAG 2.2 AA accessible, and communicates the value of each project to a non-expert within seconds.
• Each project writeup states what was built, the result, and the limitations honestly, without inflation.
• The portfolio is hyperscalable and reachable globally, with the build and design decisions documented in the repo.
• The portfolio ships with a clear narrative and presentation polish, defensible as a real product.
• The product is publicly reachable and fully reproducible from the repo.

A publicly hosted technical writeup with a stable URL and a fast, accessible reading experience, plus a public repo: the writeup itself with a clear claim, method, results, ablations, and limitations, the code and data needed to reproduce the central result, CI/CD on every commit, and a README pointing to the reproduction steps.

• A clear claim stated upfront, with the method and results structured so a reader can follow the argument.
• A reproducible experiment — code and data public — that a reader can run to confirm the central result.
• At least one ablation that isolates the cause of the result, with the experiment design explained.
• Honest, explicit limitations so the writeup reads as credible research rather than marketing.
• Clear figures and, where it helps, interactive or visual explanation to the standard set by Distill.
• Experiment tracking linked so the runs behind the numbers are inspectable.
• A fast, accessible reading experience with semantic structure and keyboard navigation.
• CI/CD that rebuilds and republishes the writeup on every commit.
• A stable public URL suitable for sharing in an application or with a referral.

• The writeup makes a clear, specific claim and supports it with a reproducible method and honest results.
• At least one ablation is reported that isolates what actually caused the result, with the experiment design described.
• Limitations are stated explicitly, and no claim is overstated beyond the evidence.
• The code and data needed to reproduce the central result are public and the reproduction steps are documented.
• The writeup is published on real public hosting with a stable URL, CI/CD on every commit, and a fast, WCAG 2.2 AA accessible reading experience.
• The writeup is written and presented to a standard a frontier-lab engineer would take seriously, with clear structure and figures.
• The product is publicly reachable and the result is independently reproducible from the linked repo.