The problem

Anchor Vision is a pre-launch app that alerts prop-firm traders when their chart markup drifts from the strategy they wrote down. I wanted to see how much of it a team of LLM agents could build on its own, with me steering instead of typing.

What I built

A TypeScript orchestrator written as a finite-state machine: Planner → Coder → build gate → two parallel reviewers → merge on double approval, with escalation states that hand design questions back to a human.

• Planner: Claude Opus.
• Coder: a ReAct-style tool-calling agent with file, shell and web tools, sandboxed to the repo.
• Reviewers: Claude Opus and GPT-5.6 see identical payloads independently. A failed reviewer call counts as a reject.

It ran on GitHub Actions ticks and built a Fastify/React app of about 80k lines. Its backend is deployed on AWS with AWS CDK (ECS Fargate, Aurora, SQS FIFO, Cognito, cdk-nag).

The hard part

Cost. I traced every one of the 592 LLM calls ($1,013 total). The Coder drove 76% of spend, and 59% of that was cache reads, because the tool loop re-sent the full context on every step. So I built context compaction, gated on a cost rule: compact only when the expected savings exceed twice the cache-write cost.

Convergence. Reviewer B rejected about 52% of rounds, and one task cost about $37 re-raising the same defects. Each reviewer now sees only its own prior issues, verdicts persist across ticks, and there is a stopping rule.

Accountability. One token-scope fault cost $29.50 and blocked 4 tasks. After it, I added an infrastructure-vs-task failure classifier, a dry-run push preflight, a "done means pushed" rule, and per-task, per-tick and rolling 24-hour spend caps backed by a per-call ledger.

Results

• 63 GitHub Actions ticks, 57 tasks merged in 13 days, median $9.03 per merged task.
• 50 agent-escalated design questions answered by me.
• Local benchmark: ingest-to-alert p95 of 24 ms.

Credits

Built with Noah Arnut and teajammin. Their work (the verify performance split, CI install, true task cost fix, git-failure classification, Playwright install and T059 rebuild) is not claimed here. Claude was my pair programmer. The repos are private; I can give a walkthrough on request.

The problem

Ask an LLM whether a Fed meeting was hawkish and it may just recite what it memorized during training. I wanted answers grounded in the actual Fed communications, and an evaluation that could tell the two apart.

What I built

• Scraped 175 FOMC statements (2006 to today) into 572 chunks.
• Hybrid retrieval: BM25 (lexical) and dense embeddings (semantic), fused with Reciprocal Rank Fusion.
• A generator using chain-of-thought and few-shot prompting on GPT-4o-mini.
• An evaluation split at the generator's training cutoff (2023-10-01), so retrieval-grounded reasoning can't hide behind memorized text.

The hard part

The "best of both worlds" hybrid lost. Queries here are mostly just a date, and the dense retriever's similar-but-wrong matches pushed the correct statement out of the fused ranking. BM25 alone reached 91.7% post-cutoff accuracy, against 75.0% for semantic-only and hybrid.

I report Hit@5 as the main retrieval metric. With an imbalanced label split, accuracy can look fine while retrieval silently fails.

Results

• BM25-only retrieval: 91.7% post-cutoff accuracy.
• Headline accuracy with prompting on GPT-4o-mini: 92%.

Credits

Claude helped as a coding and writing assistant. The design decisions, labeling and evaluation protocol are mine.

The problem

Connections gives you 16 words and asks for four hidden groups of four. A language model "knows" a lot of word associations, but the puzzle is designed around red herrings.

What I built

I framed it as binary classification: is this set of four words a valid group? A DeBERTa-v3-small backbone stays frozen and a trained head scores each group. Beam search runs over all C(16,4) = 1,820 candidate groups and decodes four groups that don't overlap.

The hard part

An early model reached a suspicious 75% accuracy. It was predicting every sample as negative. I fixed it by tying the positive-class loss weight to the negative-sampling ratio.

A structured ablation (sampling ratio, encoder unfreezing, learning rate, batch size, beam width) showed two things:

• Partially unfreezing the encoder collapsed training entirely.
• Widening the beam past a point barely helped, so the scorer, not the search, was the bottleneck.

Results

On 131 held-out puzzles under real game rules: 9.92% full-puzzle wins and 16.2% group accuracy. A zero-shot cosine baseline and an untrained head both scored 0%.

Credits

Co-authored with Ghaith Al Ramahi.

The problem

If New York makes buses free, which neighborhoods benefit most? The answer depends on many datasets that don't share a common shape.

What I built

• Merged 6 datasets with pandas and GeoPandas spatial joins.
• Combined them into a double-normalized, weighted "Bus Need Index".
• Checked the index with SciPy correlation tests.
• Published the results as Matplotlib charts and an interactive Leaflet.js heatmap.

Everything is open: the code and data are on GitHub, and the method is written up in a blog post.

Results

I presented the index at the NYC School of Data Conference, after winning a popular vote among attendees.

A sentiment classifier built from scratch in PyTorch on the IMDB 50K reviews dataset. It uses custom Datasets and DataLoaders, Bag-of-Words features (top 2,000 words), and a 3-layer network (1000 → 64 → 1) with Dropout(0.2). It reaches 87.6% test accuracy.

A clickbait headline classifier using Multinomial Naive Bayes. I compared Bag-of-Words against TF-IDF vectorization across n-gram settings (unigrams vs. bigrams) and vocabulary sizes from 500 to 2,000 features.

A random forest model that predicts bike demand across Boston's BlueBikes network, trained on 500k+ historical rides. It was selected for a lightning talk from a large pool of course projects.

Graph algorithms in Rust on real Facebook ego-network data:

• BFS for average path distances.
• Closeness centrality to find influential people.
• Jaccard similarity over mutual friends to find communities.

The problem

noon's fintech arm wanted to offer financing to its sellers, and needed to know what each seller was likely to earn over the next year, with honest uncertainty.

What I built

• A leakage-safe training table of 4.9M rows and 46 features, built from BigQuery with parameterized SQL.
• Pooled gradient-boosting quantile models (scikit-learn) that give 12-month revenue forecasts with uncertainty bands for 28,000+ sellers.
• A rules-based prequalification engine that screened sellers down to a pool of 750 for a bank-backed financing pilot.
• A self-serve FastAPI tool with event-driven batch workers, Postgres caching and role-based access control.

Results

An out-of-time backtest over 8 quarters (890K+ forecasts) cut WAPE (weighted absolute percentage error) by 15% against the strongest baseline. The system powers financing decisions worth about $200M.

[ADD MORE DETAIL: this write-up is still the thinnest on the site.]

The problem

A second reader for mammograms can catch what a first read misses, but patient images shouldn't leave the device. So the model has to be small enough to run locally.

What I built

• A reproducible data pipeline (pandas, OpenCV, scikit-learn) over 75K+ mammograms from 3 datasets (CBIS-DDSM, RSNA, VinDr) on Google Cloud Storage. Splits are 70/15/15 and grouped by patient, so no patient leaks across splits.
• A MobileNetV2 model (2.3M parameters) trained with transfer learning, tf.data and a class-weighted loss.
• Containerized training jobs on Vertex AI (NVIDIA T4 GPUs), with GCS checkpointing and pytest CI.

I also run the team: weekly sprints, task delegation, and GCP permissions and budget with our cloud architect.

The hard part

I traced and fixed a BatchNorm failure mode, then deliberately optimized for calibration over raw accuracy. I also benchmarked input sizes: 288px gave +0.012 AUROC for 15% more training time.

Results

0.83 AUROC and 82% sensitivity on a held-out test set.

The problem

BU drivers had no live view of which garages had space. The data existed as minute-level reports in AWS S3, but nothing turned it into something a driver could use.

What I built

• A real-time ETL pipeline: cron jobs load the minute-level S3 reports into normalized SQLite schemas, served through a FastAPI backend.
• A React/TypeScript Progressive Web App on Google Maps, with color-coded markers that show each garage's availability in real time.

Every two weeks I demoed to BU IS&T to agree on data schemas, data contracts and feature priorities.

Results

A full-stack platform ready for a campus-wide rollout to 2,500+ potential users.

Credits

Built with Professor Scott Ladenheim and Leonidas.

I support 200+ students in DS120 with calculus, probability and linear algebra: I run office hours and grade assignments.

The problem

SiViZ gives government, NGO and finance clients real-time insights from their data. Clients wanted to automate recurring work, like "a weekly digest of my performance metrics", without building the workflow themselves.

What I built

• Backend logic in Python on the OpenAI API that generates a workflow from a plain-text prompt, with access to the client's own data.
• A multi-turn clarification system: when a prompt is unclear, the AI asks follow-up questions before it builds anything.
• REST APIs in Java Spring Boot with API-key access to SiViZ tools, so clients can plug them into automation platforms like n8n.
• Text interfaces, smart agents and automation flows for email, reporting and task management.

Results

The workflow generator saved clients up to 10 hours of manual work per week.

The problem

How do you keep an agent aligned when it moves from a narrow goal (mine a diamond) to open-world survival, where many more behaviors can earn reward?

What I built

• Reward-based training systems for survival agents, and learning setups for progression tasks.
• RL fine-tuning pipelines in Python on MineRL, using RunPod for GPU-accelerated experiments.

Results

I co-authored a technical research post on the work, published on LessWrong: From Diamond Mining to Open-World Survival: Alignment and Emergent Behavior in Minecraft Agents.