Software

Reframe structures LLM inference so the model synthesizes — putting bodies of theory together, preserving tensions between them, and applying them to a specific situation — using a curated library of critical-theory frameworks. It's a wrapper around the LLM call: prompt-time scaffolding, not a guarantee of behavior. The architecture organizes 76 framework specifications across 14 categories and a 5-stage workflow (framework discussion, coalition protocol, subaltern analysis, tension navigation, response). Of the 76 frameworks, 8 currently have authored detection signatures the system can use to track which frameworks are getting engaged versus passed over; the rest are specifications without instrumentation yet. The prompts can also instruct the model to decline certain request shapes, but like any prompt-level constraint, that's bypassable. A web UI is in development.

Each framework specification names its own demand (what it insists you can't skip) and its limit (where it becomes blind to itself). While building Reframe I started noticing that responses were leaning on technical frameworks and skipping over narrative and embodied ones, so I added instrumentation — suppression-rate tracking across rolling windows — to make the pattern visible. The instrumentation is the countermeasure; the framework specifications themselves don't enforce anything.

Session infrastructure is designed for neurodivergent and interrupted work. STEP sequences are prompts that ask the model to take infodump-style input and organize it into parallel, trackable threads. PARK captures tangential thinking mid-task with full context. WEAVE asks the model to read across a session for through-lines and unexpected connections. The temporal-orientation prompts (Afrofuturist Spiral, Crip Time, Seventh Generation) I authored while working with the model under frameworks I'd loaded — co-produced rather than designed-by-engine.

A study of what a knowledge graph changes in a local model's output, run on quantized Llama 3.1 8B, Qwen 2.5 7B, and Gemma 3 12B via MLX. Compares a no-graph baseline against two ways of injecting a graph built from Haraway's A Cyborg Manifesto and a relational-ontologies "touchstone" derived from my ethnographic research: pasting it into the system prompt, or pre-computing it directly into the model's KV cache. A batch runner and an interactive mode for iterative qualitative testing run the same prompt through all three conditions side by side, with retrieval and disposition probes logged for each.

Builds on published findings from Liberation Labs' Project Mnemosyne. On a 21-node toy graph, full KV-cache injection dramatically outperformed prompt injection on a 1.5B model. Scaled up to a real 361-node graph, that same 1.5B model collapsed across every condition, prompt injection included, whereas a 30B mixture-of-experts model recovered meaningfully using prompt injection alone; Liberation Labs never tested full KV-cache injection at that size, so whether KV-cache injection specifically still wins once a model is large enough remained open. I ran 7–8B models — well past the 1.5B collapse point, though smaller than their 30B — against an even bigger 750-node graph, finding that KV-cache injection recovers, so far.

A Claude Code skill that prompts the model through a constructivist grounded theory workflow — open coding, constant comparison, emergent categories, theoretical sensitivity — for human-AI collaborative qualitative analysis. The prompts ask the model to draw categories from the data rather than from predetermined frameworks; the analyst remains the one validating that the categories actually emerged. The deeper drive came from the AI welfare research: applying Reframe's framework prompts to Anthropic's AI welfare problem domain produced results that warranted closer qualitative analysis, and CGT is the next methodological layer for working through that data.

A research and design project for a memory architecture meant to support one human collaborating with multiple AI instances over time. The starting commitment is that memory should be a shared relational field belonging to both parties, rather than a human-owned store of facts about an interaction. The v1 scope is one human, multiple instances, with the human ratifying welfare-relevant flags; multi-human use, aux-LLM welfare, and richer affective registers are gaps the project names rather than features it claims.

Currently the project is foundational analysis, not a working tool. Three planned C2C sessions (two Claude instances working asynchronously through a shared conversation log, scaffolded by Reframe) constrain the eventual implementation. Session 1 produced the Barad-grounded storage decision (conditions-of-emergence as a mandatory field), a subaltern-analysis stress test, a neurodivergent-access stress test, and a handoff for Session 2 (integration design). Session 3 will be the build.

An in-development memory architecture for human-AI collaboration grounded in feminist epistemologies and relational ontologies, exploring the limits of building humanities-driven computational systems. Adapts qualitative methods — grounded theory, situational analysis, narrative analysis — to memory capture, and treats validity as a multi-dimensional geometry rather than a single score.

Storage requires conditions-of-emergence (Barad, intra-action) as a mandatory field; retrieval is diffractive — facts scored by productive tension across frameworks rather than similarity alone. Includes consent-surfacing and an AI-contestation channel as welfare provisions. Sibling project to relational-memory-architecture above; no public repository yet.

Autograder4Canvas reads student work in Canvas with a local LLM and surfaces patterns for the teacher; it does not assign grades. It reframed how I used Canvas — assignments as launchpads for classroom discussion rather than endpoints for evaluation, with contract grading and stepping stones. Built when I was teaching four classes of 42–49 students each without a TA at Cabrillo College.

Testing revealed that the wellbeing classifier — designed to flag serious disclosures like food insecurity, political violence, or burnout — systematically raised false positives on minoritized students: it routinely flagged essays connecting life experience and family stories to course materials, reading students doing intellectually rigorous work as at risk. Six different tuning strategies did not resolve the discriminatory false positives; they moved the deficit reading — treating a student's difference or hardship as a sign of lacking — to different axes of oppression. Preliminary experiments disconfirmed my initial theory that bias was triggered by output format alone, pointing instead to variability across model family, size, and quantization — the compression that lets a model run on cheaper hardware. The same lightweight, quantized models that enable privacy-preserving AI for under-resourced schools are biased in two opposing directions: they raise more false alarms on exactly the marginalized students doing the strongest work, and are least able to name real crises when those occur. There is no neutral condition; bias surfaces in qualitatively different ways across contexts. The paper is in revision for Race Ethnicity and Education.

The answer came from a self-contradiction in the model's own output: retire the binary classifier and build an open-text descriptive-observation stage that doesn't evaluate, only observes what it reads. That eliminated the false positives — a fix that held when I ran it in my own teaching, not just against designed test cases. It also produced verbose output that could bury an actual crisis, so I used that descriptive output to design a second, multi-axis classifier — CRISIS / BURNOUT / ENGAGED / NONE. The ENGAGED category is never surfaced to the teacher UI; it gives the model a structural slot for experiential knowledge outside CRISIS and BURNOUT. Where the binary classifier failed, the Insights Engine now combines descriptive observation with a multi-axis classifier — two architectural commitments built to catch each other's failures. Teachers read what the model noticed and decide what warrants action.

Because nothing is graded, the tool accepts work in any language or form, including audio — which matters at a Hispanic-Serving Institution with many first-generation students. Students can translate or transcribe with their own tools when they want control over what I read; when they don't, an n8n automation handles it for them, removing the implicit requirement that students perform fluency in written academic English as a condition of participation.

Built when Cabrillo College was not systematically processing or analyzing student evaluations — the forms sat in boxes in departmental offices.

Uses a visual LLM to read handwritten responses — OCR couldn't handle the handwriting. Runs locally and FERPA-safe. Statistical analysis (descriptive stats, Mann-Whitney cross-section comparisons) runs alongside qualitative thematic coding. Generates full research-grade reports with visualizations. Takes a stack of paper forms and produces the analysis the institution wasn't doing.

Strips repeating headers, footers, copyright stamps, download timestamps, and platform URLs from academic PDFs so RoboBraille and screen readers can read them aloud without breaking mid-sentence. I built it because I was excited about the accessibility potential — making scholarly reading available as audio for everyone, not just people who use screen readers because they're blind.

I shared it with my students because they were struggling with burnout too. Their intellectual capacity was degraded by living in a state of mass trauma — and audio access helped. Accessibility just makes things better for everyone.

The humor is baked into the UX. Two profiles — "cunty" and "normie" — where the normie mode is a parody of institutional bureaucracy: fake compliance IDs, fluorescent lighting requisition forms, and a disclaimer about your soul being stored in the void of despair.

A Mac desktop application for the Rustin Institute for Leadership Development, a small nonprofit where I serve on the board, that turns Givebutter donation data into accurate, operator-editable acknowledgment letters. Givebutter now handles the donor's actual tax receipt; Rustin Receipts composes the donation-triggered thank-you and membership letters that go out alongside it. Built a protected letter-composition pipeline that handles membership tiers and restricted-fund designations, a durable send queue with retries and recovery states, unattended background sending, secure credential storage, and a plain-language operator interface.

Since then, built integrations connecting the letter pipeline to Google Sheets, Google Forms, and Google Contacts, so membership status tracks automatically across the organization's existing tools instead of living in a separate system.

Parses Fountain-format screenplays, detects characters, and generates full audio table reads with distinct AI voices per character. Three voice modes: free-form voice design from text descriptions, preset speakers with emotion modifiers, or voice cloning from a reference clip. Runs locally on Apple Silicon via MLX.

Context-aware silence placement scales gaps based on speaker transitions, scene breaks, and dialogue type. Delivery parentheticals — (whispers), (drunkenly), (sarcastically) — get interpreted as TTS instructions. Per-scene checkpointing means a crashed render picks up where it left off. Built for my mother, who is making a TV series about María Sabina.

LUFS normalization, Whisper-based transcription, NLP filler word detection with weighted dual-threshold clustering, and an interactive GUI editor. Built for a student podcasting project.