Writing

What started as a simple post log turned into 19 API routes, 41 React components, and a scoring engine I designed from scratch.

Hardware that works at -60°C, 1% atmospheric pressure, and has to survive both ascent and descent. Here's what that actually involves.

SEO and GEO are manual, slow, and disconnected. We built an agent that handles the whole pipeline autonomously. In a weekend.

DECA Ontario has thousands of students competing in business case events. Grading is slow and inconsistent. I built a model to fix that — and got it into a real pilot.

Hack Canada 2025. 24 hours, a wildfire problem, a team, and a working system by Sunday morning.

Not about generation. About output control under unreliable model behavior.

Real-time American Sign Language recognition from a webcam feed. What it took, what works, and what the honest limitations are.

A Blue Banner in FRC means you won a regional. Winning it in your rookie year — first time competing — is rare. Here's what that season actually looked like.

Most input devices are external. I wanted to see if the laptop itself could become one.

A hackathon project that turned push-ups into mouse clicks, voice commands into cursor control, and a laser pointer into a physical robot.

Space software often visualizes data after the thinking is done. I wanted the interface to participate in the reasoning.

Most fitness apps track isolated metrics. I wanted a system that treated training, recovery, and consistency as one loop.

Most SEO tools report problems. I wanted to model a system that could analyze, queue, decide, and act.

I built the interface before the backend was fully real, which forced me to think hard about architecture before integration.

I was less interested in another polished dashboard than in testing how an agent interface should actually behave under uncertainty.

Ads are built around attention. I got curious what happened if attention itself became the input.

I did not start with plugin architecture. I started wanting to understand what pitch correction was actually doing.

Typing automation is easy until you try to make it look human instead of scripted.

Driving games feel simple until you try making traction, drift, and road generation all agree at once.

Real-time systems get interesting when vision, voice, and control all have to run at once.

Productivity tools often add friction through complexity. I wanted to see how far a terminal app could go with less.

Most FRC robots use gamepads. I wanted a steering wheel, a gear shifter, and a first-person view.

Personal finance tools often drown simple questions in interface. I wanted to make the data answer first.

Most scraper projects fail from architecture debt before they fail from blocked requests.

Keyboard shortcuts add up. I built a physical controller with five buttons and a knob to skip them.

Learning Java from a textbook is boring. Answering questions to survive is not.

Good driving controls are mostly invisible. You only notice them when traction, weight, or drift feels wrong.

A small computer vision project taught me more about state, noise, and motion than the push-up count itself.

Fifty-seven lines of Python, one webcam, and a MediaPipe model. It counts pull-ups.

Mouse input feels fixed until you realize a webcam and a few geometric checks can replace it.

MediaPipe gives you 21 hand landmarks per frame. I wanted to see what I could do with just coordinates.

The elbow lever is hard to learn without a coach. I built a webcam to judge my form instead.

LeverLens tracked elbow levers. Handstands needed the same treatment, but inverted.

Recognizing rock, paper, and scissors is easier than most people think when MediaPipe gives you the landmarks.

Rock Paper Scissors needs no hardware. I wanted to see if a webcam could replace the verbal call.

Just Dance requires a console and a phone. I wanted to see how close a webcam and 174 lines could get.

A servo, an ultrasonic sensor, and a polar coordinate display. It shows you what the sensor cannot.

A camera that follows you is a common robotics feature. Getting it to work from scratch is a good test of the full pipeline.

An RFID lock sounds more complicated than it is. An MFRC522 reader, a servo, and 56 lines of code.

Before you can unlock a door with a card, you need to know the card's ID. This does exactly that and nothing else.

A simple iris authentication prototype taught me more about system reliability than about biometrics.

A simple atom model taught me that good educational software often depends on what you choose to simplify.

Quantum mechanics made more sense once I could rotate an orbital and inspect the shape instead of staring at diagrams.

Matplotlib is not a 3D modeling tool. But with enough parametric equations, you can make it look like one.

A rotating cube with a full RGB spectrum cycle and an inverse background. No models. No shaders. Just matrix math.

Simple collision rules created behavior that looked far more interesting than the code behind it.

A small simulation taught me that making motion look right is mostly about handling edge cases.

A chess game where the computer picks moves at random and the starting position changes every time. Under 150 lines.

Two-player local chess in 92 lines. The library handles the rules. The code just draws the board.

A simple voice assistant taught me more about interfaces and failure states than bigger projects did.

A fragile screen bot taught me more about constraints than many larger projects.

A small budgeting tool taught me more about state, persistence, and design tradeoffs than I expected.

A CLI budget tracker with a GUI layered on top. Charts make the same numbers easier to read.

Task managers look trivial until state, search, persistence, and interface behavior start colliding.

A menu-driven math tool that covers geometry, trig, matrices, quadratics, and graphing. Most of it is formula one-liners.

A Tkinter wrapper around the same CLI math functions. Each tool opens in its own window with dropdowns and error handling.

Searching five hardcoded recipes taught me more about interface state than the recipes themselves.

A tiny plant simulator taught me more about state transitions than projects ten times its size.

A 4x4 grid, eight image pairs, and a timer. No sound, no animations, no restart button.

A school assignment about arrays that shares a validation library with the grade analyzer. The interesting part was state management.

Reads section-based grade files, computes stats, and writes results. The most interesting part is a validation library I overengineered.

Most school projects stop at interpretation. I wanted this one to connect literature, history, and interface design.

Small projects teach you where software state gets messy faster than big ideas do.