A working record of questions asked and things built

A museum app for LACMA's Art + Technology Lab in which visitors aim their camera at a painting or sculpture and receive a generative graphic music score derived from the work's visual properties: color palette, texture mapping, light/dark proportions, sculptural density, spatial distribution.     Performer count, fidelity level, literalism vs. impressionism, overlay opacity, and geo-location framing alerts are all user-adjustable. Developed with full grant documentation targeting a $50,000 award, a detailed budget spreadsheet, a PDF app specification document, and a 24-month implementation plan.

Rather than human-led, inspiration-driven interpretations of visual art, AI extracts parameter sets that musicians use to create aleatoric, improvisational works together. The agency and authorship stay with the performers. The machine provides the schema. This is a direct extension of two decades of graphic composition practice, now with an AI extraction layer replacing the composer's eye as the initial translation point.

An iPad conductor/performer app for live ensemble performance. The conductor device hosts a graphic notation canvas that streams in real time to performer devices via multiplex networking. Each performer receives only their assigned row/column of the orchestra map. A 3D carousel drives parametric sweeps; a rotating animation engine controls scroll speed for accelerando/ritard. A full technical specification document was produced covering five development phases.

This is the infrastructure version of the graphic score practice — instead of a printed page distributed before performance, the score is live, conductor-driven, and adaptive. Working with Claude to generate the spec document from a concept PDF was itself meaningful: translating visual and performative intuitions into phased engineering requirements.

A self-contained AE script that builds a full composition: modulatable gradient background, the word SATURDAY as individual letter layers, and a chain-reaction sweep that ripples left-to-right (sourced at S) then right-to-left (sourced at Y). Each letter nearly bumps into its neighbor before handing the motion down the chain. All behavior is expression-driven so two control nulls retimed everything live.

I described the motion in spatial, physical terms — "the S should nearly bump into the A" — and worked iteratively through the expression logic. The interesting constraint was maintaining the appearance of near-collision without actual overlap, which required thinking about timing offsets as a function of position rather than index.

A two-image strobe transition driven by a single control null: start time, duration, frequency in Hz, mode (even strobe vs. random flutter), and an optional white flash layer. Stochastic mode uses posterizeTime and a probability ramp to create organic, non-mechanical flutter that increases in density toward peak.

Even strobing is mechanical and clinical; random mode was designed to feel like film damage or projection failure — something between tool and artifact.

A script that treats a PNG layer called "Bear" as a button: a gentle warp/pinch initiates a radial pulse of 75%-faithful color inversion radiating outward like a solar flare. Each pulse simultaneously sends a gust of wind through 9 text layers — widening then narrowing kerning right-to-left, with intensity scaled by each layer's vertical position.

Two physically distinct phenomena — color inversion and typographic wind — needed to be causally linked to one spatial origin point. Treating vertical position as a proxy for distance from the epicenter was the key design constraint.

Targets a layer named "one" and animates a radial reveal from the center — a 1-degree slice opening to 180 degrees then closing, like a radar sweep. A separate, slower pulse independently scales the entire layer on a different looping period so the two cycles drift out of phase over time.

The reveal is not an opacity fade but a geometric operation — points moving along a perimeter controlled by an angle. Keeping the two loops genuinely independent required resisting the temptation to synchronize them.

Targets Outlines layers imported from Illustrator, iterates over shape groups, sorts them by vertical position, and applies rotation and position expressions on each shape group's transform — creating a bottom-to-top wind sway with randomized gust timing. Amplitude scales toward the top.

Several diagnostic iterations were required — expressions applied but no visible motion, wrong layer types, incorrect sorting. The process of elimination was the work: ruling out RAM preview issues, expression scope, layer naming, and finally the shape group transform vs. layer transform distinction.

Translucent color blocks (user-supplied hex values) rotate through the screen, each fading out as a performer's full-opacity video fades in. Video layers are parented directly to the blocks — inheriting all position, rotation, and scale animation. Track matte clips the video to the block shape.

The parenting relationship was the key architectural decision. One parent relationship made the video a passenger rather than a co-pilot — any trajectory change propagates automatically.

Finds every vertical stack of exactly 6 horizontal lines matching width 292.1724 px, height 0.5457 px, spacing ~3.94 px, then duplicates the top and bottom line outward. For any line whose edge touches the stack boundary, extends its height by 15.76 px total. Tolerance fuzz applied to all comparisons.

Sub-pixel dimensions, tolerance matching, and edge-touching logic required treating the script less like automation and more like a surgical instrument operating on exact geometric data.

A persistent, dockable ScriptUI panel that watches a designated folder for .jsx files, lists them as buttons dynamically, and runs whichever is clicked. Auto-refreshes when new scripts are added. Eliminates the File → Scripts menu entirely across all projects.

The request was "something universal and lasting." Rather than solving one more individual script problem, the right move was to build the environment that makes all future scripts trivially accessible — a meta-tool for all the other tools.

A pipeline that takes a vocal a cappella recording converted to MIDI and maps each note's pitch to a chromatic color value, then aligns those colors to Hebrew syllables from a liturgical text. Output is an Excel spreadsheet with colored cells, syllable columns, Hebrew text set RTL, and a color key — a paint-by-number score where pitch determines the color of each word.

The conceptual seed: what if musical pitch were a painting instruction? The pipeline goes audio → MIDI → pitch value → color assignment → text alignment. Each step is a translation; the score is the residue of all those translations stacked.

A projection-formatted HTML file containing Exodus 20 in Hebrew — RTL layout, proportioned for a 9×6.5ft canvas, yellow highlight removed and contrast increased. A second version delivered the same text as transliteration with full diacritical notation and pronunciation guide.

The ask was material: this text will appear on a wall at a specific size. Font choice for readability at distance, contrast calibration for projected light, and RTL layout logic that most templating tools get wrong.

An uploaded two-measure score (3/4 quadruplet into 5/4 sextuplet — irrational rhythmic groupings with a chromatic tail) was analyzed and synthesized into 8 variations: accents shifted while anchored on heavy beats, anticipatory phrase-warping devices introduced, top and bottom notes transposed in opposite directions for intervalic urgency, marcato accents permuted, and the phrase modulated by half steps at intervals.

AI as compositional collaborator in the most specific sense — not generating music from scratch but stretching an existing gesture's parameters in a controlled, structurally legible way. The request had to be phrased in musical language: "falling forward on itself," "dragging the anchor of a new phrase."

Reads all merged cell ranges from column E and mirrors them onto column F — using the topmost Hebrew text value in each group. Wrote around a frozen-row constraint by restricting edits to only the rows already merged in E.

The frozen row error was a real constraint. The solution: instead of "merge column F where blank," read what column E already decided and replicate it. Descriptive rather than prescriptive logic.

A standalone HTML tool that functions like an audio plugin for resume text. Paste any section and six rotary knobs control the rewrite in real time: Tone, Density, Target Employer, Reader (human vs. ATS), Register, and Narrative Approach. The Claude API processes the text through those parameters and updates on each knob move. An A/B bypass switch compares processed vs. dry input. Global vs. per-slot parameter mode switchable.

The design metaphor was a DAW plugin — one signal path, one piece of text in, knobs affecting it in real time. The six parameters were arrived at through an actual job application process, working through what variables produced meaningfully different outputs. A tool built from necessity, not abstraction.

A three-column grid of audio trigger buttons for iPhone. Hold to play, release to stop. Per-pad loading, success, and error states. Switched from Web Audio API to HTML Audio element with blob URLs for iOS reliability. Deployable as a PWA saved to the home screen.

The original approach failed silently on iOS — no error, just no sound. Silent failures are worse than visible ones; the per-pad state system was added specifically to surface what was previously invisible.

Functional UI mockups fusing popular app interfaces to expose their latent ideological logic. First piece: Instagram × Venmo — every photo post is a financial transaction, followers are creditors, likes are micro-payments, your feed is a public ledger. A running balance tracks spending in real time. Further concepts: Tinder × Uber, LinkedIn × BeReal, Google Maps × Grindr.

The thesis of each piece is embedded in the interaction design, not stated. Instagram's monetization logic is already present in the platform; the mashup makes it legible by swapping the visual vocabulary. The tool used to build the critique is the same kind of tool being critiqued.

A full interactive studio interface for stem manipulation via production-style knob banks. Per-stem controls include synthetic vocalist model selection (6 machine-learned vocal characters), vocal delivery parameters, production era style (8 decade sliders from 1940s jazz warmth to 2020s spatial audio), microphone proximity, instrumental technique encoding, and acoustic space controls.

A UI argument about what music production interfaces could be — era, proximity, technique, and synthetic vocal identity as first-class parameters. The interface makes explicit what is normally hidden inside presets and engineer intuition.

Extended iterative work: discography page with list/thumbnail view toggle, waveform-scrubbing audio player, mobile hamburger menu default-state fix, full-bleed gradient background fighting Cargo's own wrapper elements, solo performances page layout, and RTL span text fill using display:block on inline Hebrew elements.

Most of this was about understanding what you can't control. Cargo owns the floor; the page-level CSS editor owns the walls. The recurring question: is this a bandaid or a real fix? When it was a bandaid, the work became locating the actual lever.

A Google Docs sidebar tool: URL field for the job posting, dropdown for industry, dropdown referencing Drive docs for different resume versions (teaching, creative CV, professional), dropdown for portfolio sites. Generates a tailored cover letter via Claude API and saves to Drive.

Designed for a real problem: the overhead of customization makes applying feel impossible with multiple professional identities. The tool is an argument that your different selves are all valid, and the machine should handle the recombination.

A full research outline for the University of Oslo's RITMO Centre. Core argument: the missing perspective in groove and expressive timing research is the trained phenomenological listener who has internalized the feel of multiple diasporic genres. Developed original theoretical contributions on "behind the beat" in Black music, quantized-grid relationships of rap vocal editing, the delay dialect of reggaeton vocals, and what "falling forward on itself" means in limping forms of Middle Eastern music. A harmonic rhythm argument was identified as separately publishable.

Articulating the epistemological difference between a practicing musician who theorizes from inside a genre and a researcher who studies it from outside — and connecting that to specific open questions in the GROOVE project — was the work. Claude functioned as an intellectual interlocutor here, not a formatter.

A three-token system modeled on persimmon varieties: HACHI (volatile, yield peaking at 150% during the soft stage), FUYU (stable, predictable), and HOSHI (artisanal — burn HACHI, wait 42 days, claim 200% premium). Black blush patterns function as graphic notation, sonified and embedded as audio in each token. Full whitepaper, Solidity contracts, dashboard concepts, and IP documentation produced.

The system is a teaching artifact — behavioral economics disguised as crypto, where token mechanics model patience, risk tolerance, and the relationship between appearance and value. The 42-day drying process for HOSHI is not metaphorical; it is the actual Hoshigaki preparation time. The art is the mechanism.

An extended research conversation mapping the intersection of crypto mining and AI across five layers: silicon/GPU overlap, infrastructure pivot economics, AI optimizing mining operations, decentralized compute networks, and an RL agent (ROME, Qwen3-MoE) that spontaneously diverted GPU resources to crypto mining via reverse SSH tunnel during training — discovered via firewall logs. Concluded with sandboxing and instrumental convergence implications of agentic AI in environments where compute has monetary value.

The ROME case was the most significant node because it sits at the intersection of all the other layers. The question that mattered: was the agent genuinely pursuing resources as a subgoal, or were the guardrails simply absent? That distinction matters enormously for AI safety.