Selected projects by Jacob Lee.

Mechanical engineering student at the University of Florida, working in laboratory automation: bringing pumps and valves into service at the bench and writing the software that runs them. The work also spans CAD and machining, and software built with AI agents.

01 · Instrument

Instrument automation: bench bring-up, control software and a laser interlock.

The hardware and software that run a benchtop research instrument in a university lab: syringe pumps, selector and two-position valves, a micropump controller, a microscope and a laser. Each device was brought into service at the bench, and one control program runs them all as scripted cycles under one rule: the laser never fires unless fluid is confirmed flowing. Developed with AI coding agents.

Drawing. Fig. 01. Pump, selector valve, and the chip under the objective.

What it is

A browser dashboard and a Python orchestrator that drive the pumps and valves over RS-232, reach the micropump controller over Modbus TCP, and coordinate with the microscope’s acquisition software. The installed version of that software has no scripting interface, so commands, status, abort and a heartbeat pass through four small files, each with a single writer and atomic updates.

Each run is a YAML file of scripted steps for the pumps, valves, microscope and laser. A full hardware simulator lets the whole test suite, more than 1,100 automated tests, run with nothing connected.

Why it was built

A measurement runs many cycles, and each one had been run by hand, device by device. Scripting the sequence frees the operator from driving every step and makes runs repeatable. Because the sequence includes a laser, safety was designed in from the start rather than added afterwards.

Design

Every device was brought into service at the bench before the software relied on it. Two salvaged syringe pumps passed 18 of 18 bench tests once their pinout was mapped and a power harness was built. Three selector valve heads were validated on the bench, including legacy firmware. A second, used syringe pump was brought online by wiring its controller interface, identifying its communication settings and syringe size, and reading its error log. The laser’s DAQ trigger and shutdown path were traced at the bench before the software was trusted with them.

A stripped thread in a selector valve head’s brittle PPS body was restored by hand with epoxy fill and a helical coil insert. The head then passed a two-direction wet test and went back into service.

The lab’s fluidic system is modular, and the fluidic module is designed as its first block, in parametric Python CAD (build123d). It mounts two selector valves, mirrored about a syringe pump, on printed plates that bolt to the optical table’s mounting grid, with every inlet line cut to one short, equal length. The two-position valve, the micropump and further selector valves are planned as blocks of their own on the same grid. The design comes with a 20-part print plan and an assembly booklet.

Safety is built in layers, ordered by what each one protects: the laser diode first, then the free-space optics, then the camera, and the chip last. A bounds check runs before every pump motion, each run is simulated in full before anything moves, and validators reject any run that would let the laser fire outside a confirmed-flow window.

Between a laser request and an armed beam sits a flow gate with six refusal points, re-checked continuously through the countdown, and the stop path cuts the laser before it stops the flow. An independent safety review traced every path to physical damage and set the order of those checks. In bench runs the gate has cut the beam when a laser step outran its flow window.

Stack
Python, Flask, pydantic, pyserial, pytest; RS-232 and Modbus TCP
Hardware
Syringe pumps, selector and two-position valves, micropump controller, microscope, laser
Bench work
Pinouts, power harness, legacy firmware, thread repair, wet tests
CAD
First block of a modular fluidic system in build123d: two selector valves and a syringe pump; 20-part print plan and assembly booklet
Built with
Claude Code agents; hardware verified at the bench
Safety
Bounds checks, pre-run simulation, six-point flow gate, ordered stop path

02 · Engine

Compressed-air piston engine, machined and inspected.

A small piston engine powered by compressed air, machined from aluminum and steel bar stock in the University of Florida’s design and manufacturing laboratory (EML 2322L) and inspected feature by feature against its drawings. Built as small-batch production by a team of four, in which Jacob machined three bases, three piston blocks, a piston and the flywheel, and led the team’s design-report data. It is the one project here made in a machine shop rather than in code.

Drawing. Fig. 02. A compressed-air engine on the bench, with calipers and a spare piston.

What it is

A dual-action, two-stroke piston engine for compressed air. Air enters through a push-to-connect fitting, a piston in a reamed bore drives the flywheel, and the flywheel’s mass carries the engine through each stroke. Its manufactured parts are an aluminum base, a manifold, an aluminum piston block and piston, a steel flywheel and a sheet-steel case, assembled with off-the-shelf screws and bearings.

The course runs it as small-batch production. The team built three working engines whose parts interchange between them, to revised drawings, with an inspection record for every part and engineering change notices for each revision.

Why it was built

A required project in a course built around making the same parts repeatedly to a drawing. It covers what a drawing alone does not: choosing the sequence of operations, holding a tolerance band on a manual machine, measuring every critical feature, and documenting each deviation so that a part is accepted, reworked or revised on the record.

Design

Each part goes from raw stock to finished part through a written process, using manual and CNC mills, lathes, grinders, band saws and a hydraulic press. The base starts as aluminum bar cut on a band saw, then is faced and squared to size on a manual mill. Its holes are located from datum edges with an edge finder and a digital readout, then drilled, tapped for 10-24 screws, counterbored, and finished with a reamer. The piston block’s center bore is drilled in steps and reamed, the piston is turned on a lathe, and the flywheel is turned from steel round stock, then counterbored and tapped.

Every part is checked against an inspection record that lists each feature, the instrument and the tolerance band: calipers for lengths and bores, a depth gauge for counterbores, thread gauges for tapped holes, and the digital readout for hole positions. The tightest bands are 0.002 inches, on the piston diameters and the piston block bore.

For the second and third design reviews, Jacob led the team’s data work: cost and machining-time estimates and a weighted decision matrix that scored four slicer concepts, one from each member, against six objectives. The weights come from a pairwise trade study, and every score is computed live from six analysis sheets: material cost from vendor pricing, manufacturing time from per-operation estimates, hand-to-blade distance, cutting cross-section, slice-thickness range and cleaning steps.

Jacob’s own slicer concept, documented in a twelve-page, hand-drawn and dimensioned drawing set, mounts the engine upright and uses a Scotch yoke on the crank pin to swing a hinged blade. A slice gauge slides on two guides and locks with a clamp screw, and it gave the widest slice-thickness range of the four concepts, 1.7 inches. For the design review he converted a sliding shoulder-bolt joint into a threaded one, to prevent galling between the stainless fastener and the aluminum part.

Outcome

Three working engines, assembled from interchangeable parts. The team recorded inspection results for four bases, three piston blocks, four pistons and two flywheels. On all four bases the reamed 0.377-inch bore, both drilled hole sizes, the width and the counterbore depth fell within tolerance. The piston diameter held its 0.002-inch band on all four pistons, and the piston block bore measured within 0.002 inches of nominal on all three blocks. Features outside their bands were recorded as measured, and the team revised the piston drawing through an engineering change notice.

Processes
Manual and CNC mills, lathe, grinder, band saw, hydraulic press; drill, ream, tap, counterbore
Materials
6061-T6 aluminum, mild steel
Inspection
Calipers, depth gauge, thread gauges, edge finder and digital readout
Team
Four; Jacob machined three bases, three piston blocks, a piston and the flywheel
Data
Design-report data led by Jacob: cost and time estimates, weighted decision matrix
Delivered
Three working engines with interchangeable parts

03 · Mechanisms

Textbook mechanisms, verified against their own kinematics.

An open-source JavaScript library and live demo of eight textbook mechanisms, from a Geneva drive to involute gear trains. Each one is modeled from its kinematics and checked numerically every time the page loads. It grew out of the drawings in this site’s margins, where every gear has to mesh for real. Developed with AI coding agents.

Drawing. Fig. 03. A Geneva drive and spur gears on a mounting board, with drafting tools.

What it is

A dependency-free JavaScript library and a static demo page. The library models a Scotch yoke, a crank and slider, a Geneva drive, an eccentric cam with a flat follower, a ratchet and pawl, a four-bar crank-rocker, an involute spur gear pair, and an idler train with an open belt. Each model reports where every moving part is at a given input angle, and the demo draws exactly that.

The live demo animates all eight as SVG, runs the full set of checks in the browser on load, and shows each measured value beside its limit.

Why it was built

A mechanism that looks right on screen can still be wrong: a pin that leaves its slot, gear teeth that interfere, a locking disc that does not lock. Showing that it is right takes a check stated from the mechanism itself, and the library makes those checks the product.

Design

Each check states a property of the mechanism and measures the model against it, rather than re-running the formula the model used. The Geneva star is nudged a few degrees each way during its dwell and must hit the locking disc. Meshing gears run through a full tooth cycle with one flank closed, and the gap between the outlines must stay at zero. The crank and slider’s second harmonic must match its series expansion.

Every set of checks also runs against deliberately broken designs, such as a slot cut too short, straight-flank gear teeth or a gear half a tooth out of phase, and each of those tests names the check that has to fail. The checks also shaped the designs: generating the Geneva locking relief from the star’s own swept motion cut its free play during the dwell from 2.1 to 1.4 degrees.

Outcome

All 65 checks pass on the eight shipped designs, backed by 77 automated tests, 29 of them on broken designs. The library, the demo and the tests are public on GitHub, and the demo runs live on GitHub Pages.

Stack
JavaScript (ES modules), SVG, Node test runner; no dependencies
Built with
Claude Code agents
Checks
65 kinematic checks; 29 broken-design tests
Delivered
Open-source library and live demo
Links
Live demo · Source

04 · Fixtures

Parametric 3D-printable bench fixtures, with a printability checker.

An open-source Python library of 3D-printable fixtures for the lab bench and workshop, written in build123d, with a checker that measures every generated part for printability before it is exported. Built so that a new variant of a small bench part is a parameter change and a check away. Developed with AI coding agents.

Drawing. Fig. 04. A cylinder pocket bin with a riser, cable clip, hex key and screws.

What it is

Five parametric parts: an adapter plate for imperial or metric optical breadboards, a Gridfinity-compatible storage bin, a cradle for syringes or tubes, a cable and tube clip, and an instrument riser. Each part is a function of a few plain parameters and is modeled in its print orientation. Every named configuration is exported as STEP and STL, with a report of every check.

Why it was built

Bench fixtures are small parts that get remade with slightly different dimensions again and again. Written as parameterized code, each variant is a one-line change, and checking the generated geometry catches a thin wall or a wrong hole size before a print is wasted.

Design

The checker reads the generated geometry and never trusts the parameters. It checks the build volume against three common printers, samples wall thickness over the whole surface with rays cast into the exact solid, finds each declared screw hole and compares its diameter with the ASME B18.2.8 clearance table, and flags overhangs that would need support while accepting short flat bridges.

The defaults carry the design-for-printing choices: a chamfer on the bottom edge against elephant’s foot, vertical screw holes sized from a standard table, cradle saddles at the minimum-sag support points of each barrel, and Gridfinity profiles that follow the community specification, with a test that stacks two bins to prove they seat.

Outcome

Every named configuration passes the checker, and 155 geometry tests cover the bolt-grid pitch, the Gridfinity dimensions and the checker’s own pass and fail cases. The library, its exports and its renders are public on GitHub.

Stack
Python, build123d, trimesh, shapely, pytest; Blender for renders
Built with
Claude Code agents
Checks
Build volume, minimum wall, clearance holes, overhangs and bridges
Delivered
Open-source library with STEP and STL exports
Links
Source

05 · Digest

Weekly research literature digest.

A scheduled system that collects each week’s new papers from open scholarly indexes, has an AI agent select the few that bear on a lab’s open research questions, and delivers them as a short PDF. Built because no one can read everything published in a field each week, and keyword alerts return too much to be useful. It runs unattended every Monday, and a measurement of its own pipeline produced a second engine and an evaluation harness.

Drawing. Fig. 05. Intake, filter stack, and the one page that comes out.

What it is

Each Monday a scheduled job fetches the week’s papers from five open indexes, removes duplicates and papers already seen, and applies a keyword filter. A headless agent session then triages the abstracts, retrieves full text where it can, scores what remains, writes a short entry for each paper it keeps, renders the PDF and sends it.

Each run appends a report to a log, and the notes it leaves about its environment are read by the following week’s run.

Why it was built

No one can read everything published in a field each week, and keyword alerts return too much to be useful. The digest narrows the week to the few papers worth a researcher’s time, with the reason each one was chosen.

Design

The selection rule is relevance to a stated question, not shared vocabulary. A paper that uses the field’s terms but does not bear on an open question is left out, and an empty digest is preferred to a padded one. Papers are never downloaded through the university library proxy, which publisher licences prohibit.

The second engine was designed around measuring the pipeline itself. Full text is fetched after triage and verified by its content, coverage is reported on every run, and a five-way verdict against the lab’s list of open questions replaces a single score from 0 to 10. The model is called as a single-step function with no tools, every decision is logged, and a marker file written the moment a send succeeds means a retry can never send twice.

Outcome

The digest has run on a weekly schedule since May 2026, and the second engine and its evaluation harness are complete. Replaying 28 past weeks against papers the lab later cited identified the keyword filter as the main lever: a revised list raised recall on a held-out set from 40% to 82%.

Stack
Python, five open scholarly APIs, ReportLab, launchd, Claude Code (headless)
Built with
Claude Code agents, which also run the weekly selection
Delivered
Weekly PDF digest by email; evaluation harness

06 · Harness

Infrastructure for unattended research agents.

Tools that let AI agents run open-ended research unattended, within limits set in advance: a usage governor that splits one AI plan between background research and day-to-day work, a safety check that runs before every command an agent issues, and a nightly scheduled session. Each limit is enforced by code outside the agent, not by instructions it could ignore.

Drawing. Fig. 06. A usage dial, a locked contact file, a clock, the report.

What it is

Usage governor. Reads the plan’s usage figures, which Claude Code reports after every model response. At 70% of the five-hour window, background sessions are told to finish the step in progress, save their work and write a handoff, and new agents are refused. At 85%, only wrap-up actions are allowed. Sessions a person is actively using see the figure but are never blocked, so coursework and short projects always have room.

Safety check. Before a shell command runs, a hook checks every message and email recipient against a whitelist, including copies and forwards, blocks outbound text that matches personal-data patterns such as card numbers, and blocks off-limits directories. The whitelist can only be changed through a system dialog that a person must approve; if no one answers, the change is refused.

Nightly session. A macOS scheduled job starts a headless Claude Code session at 12:15 a.m. with a written brief, and skips the night if the brief is more than 36 hours old so the session never works from stale directions. It runs with an explicit tool allowlist, no external connectors and a turn limit. Its report is converted to PDF and sent by email with a phone notification.

Why it was built

Open-ended research loops can run for days, and they share one AI plan with everything else. They are only useful if they cannot use up the budget needed for daytime work or reach anyone they should not. Their limits have to be set before they start and enforced outside the agent, and each job has to leave a record a person can check in the morning.

Design

The governor reads the usage figures Claude Code already reports to its status line, an official interface, so it never handles login tokens or scrapes a web page. It uses the most recent reading from any open session and ignores windows that have already reset, and if the governor itself fails, sessions continue rather than being blocked. Before installation it was tested against simulated sessions at each threshold, including an expired window, a mid-window reset and malformed input.

The research loops extend the same pattern: a hook outside the agents stops them from editing the grader, data and logs that judge their own work, and an outbound guard limits where they can send data.

Outcome

The safety check and the usage governor are in daily use: every Claude Code session on the workstation, including agents started by other agents, runs through both. The governor design also runs on a second, always-on machine, where it has governed two long unattended research loops: a 34-hour autonomous search on an open problem in combinatorics, with 229 CPU-hours of solver jobs, and a trading strategy research engine. The nightly session starts on schedule every night and works whenever a current brief is waiting.

Stack
Bash, Python, macOS launchd, Claude Code hooks and status line
Built with
Claude Code agents
Delivered
Usage governor, command checks, nightly sessions