Joe Laskowski

Hybrid retrieval. A disk-backed FTS5 keyword lane runs next to the vector lane, and the two get fused by reciprocal-rank fusion. Embeddings are famously bad at exact identifiers, so case numbers and filenames and account IDs stay findable. A cross-encoder then reranks the fused pool in-process.

GraphRAG sits on top. An LLM pulls entities and relationships out of each document, cached by content hash, merges them into a graph, clusters that into communities, and summarizes each one. Relational questions and big "what's going on across the whole corpus" questions get their own tools.

It knows about time and domain. Chunks carry the date ranges they mention, so asking about a specific year filters automatically. Every chunk is tagged with its top-level folder, and a scope argument keeps fiction from contaminating a factual answer.

Sync respects my compute. Change detection runs in 2 passes, a quick mtime scan and then a content-hash confirmation, because a folder syncing between machines rewrites timestamps constantly and I got tired of re-embedding files that hadn't changed. Embedding reuse is chunk-level. Edit one paragraph of a big document and exactly one chunk gets re-embedded.

Everything else is local too. Tesseract pulls text out of scanned documents while Florence-2 writes a description of standalone images. There's an optional PII detector that scans at ingest and masks identifiers in tool output before they reach a host's context. It also refuses to save a memory note containing a raw one.

cowork-graph handles what embeddings handle badly. It's a SQLite knowledge graph parsed out of the same markdown, and it answers structural questions: what's active, what's blocked, what links to what, what got decided and when. Markdown stays canonical in both systems. Every index is derived state I can throw away and rebuild.

pixeldrops-research-mcp conducts. It owns the per-video manifest, the stage machinery, and the gates: packaging, angle, script, shot plan, asset, QC, final cut. Each gate has its own policy, confidence, and exception path. An advancer walks the chain, skips stubs, halts for me where the policy says to, auto-passes where it doesn't, and mirrors spend as it goes. The research itself wraps Gemini, Perplexity, and OpenAI.

scriptcast-cli turns an approved script into narration and timing. A 7-rule priority chunker splits text for synthesis without ever breaking mid-sentence or inside an emotion tag. Emotion tags get passed through to the voice model, production markers get stripped before anything can read them out loud. WhisperX then force-aligns the rendered audio back against the script and produces sentence-level beat timestamps. Everything downstream keys off those.

The shot planner reads the script and the beats and emits a plan for every cue: a primary layer that's either a generated image or a scene authored in code, plus overlays. Data motif, citation lower third, kinetic type, or code composited over image. That plan fans out into the artifacts each tool consumes, and I sign off once instead of approving 150 decisions one at a time.

shotlist is where I spend most of my time. It parses a markdown prompt sheet into a grid of assignable slots. Click a slot and the prompt lands on the clipboard, paste it into an image model, drop the result back, click to assign, and the file gets renamed and tracked. No database, no auth, the filesystem is the source of truth. One more click deploys config, beats, images, and audio into the renderer and registers the composition.

framecast-cli assembles in Remotion, and it takes 2 completely different inputs through the same path: generated stills, or scenes written in code. Ken Burns motion in 4 patterns, crossfade and zoom-dissolve transitions, spring-animated title cards, lower thirds fired on beat boundaries, kinetic typography, and a per-era color grade and film texture so 1995 material doesn't look like 2025 material. An LLM classifies the era way upstream and the value rides through the entire chain.

The data motifs are my favorite thing in here. An authoring step pulls figures out of the researched script, and framecast turns them into animated overlays bound to specific beats. Counters, node graphs, dials, with per-cue overrides. The components are a discriminated union, and the architecture made a promise: adding a new motif variant should cost 1 union member and 1 switch case, with nothing existing getting reshaped. That's held 3 times now. The node-graph variant went in and its sibling components came out byte-identical.

Citations get the same treatment. On-screen source attributions authored per episode, resolved by ID instead of position, rendered as lower thirds that coexist with motifs on the same slide. yt-publish-cli closes it out with caption generation and the publish push. All 4 channels carry a full kit of themes, motion profiles, signature motifs, and transitions.

Seven market data providers sit behind circuit-breaker fallback chains. When a vendor rate-limits or falls over, the breaker opens and the next one picks it up. Looks like overkill right up until the day a provider goes dark mid-session.

Twenty-three technical indicators feed a normalized −10 to +10 signal score. LLM sentiment and directional analysis run alongside the quantitative signals.

There's a full paper-trading context with portfolios, orders, positions, and live P&L, so a strategy can run against streaming data over WebSocket without any money on the table.

It's parked. I pivoted to side projects that had some chance of generating revenue. The code's still there and I still like it.

Quality gates are the spine. Lint, test, build, and git state get checked between stages, with auto-fix where auto-fix is safe, and the loop won't advance past a red gate. Nine language profiles detect their own environment, including Python across conda, venv, poetry, and pdm, so the gates run the right commands without being told.

Twelve JSON schemas enforce cross-module integrity, with a suite asserting that profiles, agents, and gates stay structurally consistent with each other. With this many moving parts, those tests are what stop a rename in one place from quietly breaking 3 others.

It learned from being corrected. A self-improvement mechanism watched for cases where I overrode its behavior and proposed amendments to its own rule files.

Then I retired it. The platform kept shipping native features that did what my abstraction layer did, and my abstraction layer stopped helping and started getting in the way. I pulled it out of every project and went vanilla. Building it taught me how these systems behave under load. Knowing when it had stopped earning its keep was the harder call, and I've left the repo public because both halves are worth reading.

Period locks mean a closed month can't change under a report that already quoted it. Checksummed migrations mean a schema change that didn't apply cleanly fails loudly. Pending-to-posted carryover handles the window where one transaction exists twice in 2 different states. Synthetic pairs keep a transfer between entities from reading as income on one side and an expense on the other.

A doctor command runs integrity checks across the whole ledger and reports drift before it lands in a report, which is well before somebody makes a decision off a bad number.

Categorization learns. Rules live in YAML, so adding a pattern re-categorizes matching historical rows on the spot, with a full recategorize pass available when the rules change in a big way.

This replaced an earlier Flask and Plaid budgeting app I built, used for a while, and outgrew. That one taught me what the problem actually was.

A card and template engine composes prompts out of reusable structured pieces instead of string concatenation, and a multi-pass critic reviews and revises the assembled result before it ships.

The regression suite is the load-bearing piece. Thirty cases run against stored baselines, so an edit to the compiler or the cards can't silently degrade output. That's the failure mode that makes most prompt tooling untrustworthy after a few months of tinkering.

Single user by design. The API key gets passed per request from the browser and never persists server-side, and I reach it across devices over a tunnel.

Honest status: I don't reach for it as much as I expected to, partly because the models got better at the thing it compensates for. It's still genuinely handy when a prompt has to be exactly right.

Revenue-per-keyword scoring is what keeps it from being a content mill. Volume and difficulty are cheap to get. What matters is expected value per page, and the pipeline ranks candidates on that first.

GEO scoring (generative engine optimization) grades finished pages on citation-readiness across ChatGPT, Perplexity, Google's AI surfaces, and Claude. The bet is that getting quoted by an answer engine matters more every year than ranking on a page of blue links. I built that stage before the acronym was in common use, which was either good timing or a lucky guess.

Copy and imagery get generated in the same pass, copy from a mix of models and illustration from 2 image providers, then assembled into a static site with a web dashboard front-ending the toolchain.

An AI-scored opportunity board and a trend radar rank products against each other, so what I open in the morning is a ranked shortlist.

The listing generator writes titles, hooks, and descriptions, and a separate content pipeline produces video hooks, scripts, and shot lists. That's the creative bottleneck, automated far enough that I'm editing.

Fulfillment is an explicit state machine. Order states in dropshipping have real transitions and real dead ends, and modeling them as a status column is how orders go missing.

A token-usage dashboard tracks my own model spend against the operation. That number is the difference between a tool that's profitable and one that just looks busy.

Two machines, two schedulers, one alert channel. A systemd timer covers the Linux side and Task Scheduler covers Windows, and both report into the same place, so a silent failure on either surface shows up the next morning.

It alerts on success too, at least while I was still learning to trust it. A backup system that only speaks up when it breaks looks identical to one that quietly stopped running 3 months ago.

The restores are tested. Both surfaces have been round-tripped and verified byte-identical by hash. Almost everybody skips that step, and it's the only one that proves the rest of it works.

It only works against self-custody addresses. Exchange deposit addresses sit inside shared omnibus wallets, so querying one tells you about the exchange's pooled balance and nothing about your holdings. The app tells you so. I learned that by building it and watching it lie to me once.

Live on both axes. Price comes from an exchange API, balances come off the ledger over a WebSocket subscription, and the two reconcile into a valuation that updates without a refresh key.