DEV Community: Jordan Forrest

The green lamp lies: ten months growing a harness around Claude Code

Jordan Forrest — Wed, 30 Sep 2026 17:22:54 +0000

Forty-two days on shift. The diesel generators throb under your boots until you stop hearing them. Hundreds of indicator lights on the alarm screens.

Every one of them green.

Then the deck changes.

Not an alarm. Not a light. A vibration through the steel that is not right. The resonance shifts and something in the back of your skull sits up before any gauge does. The panel says the plant is healthy. The deck says otherwise.

The deck is right.

Different engine room now. My desk. An integrity check reports clean. Exit code zero. I had piped it through tail to keep the output short, and $? handed me the exit status of tail. The real exit was one. Under the zero sat a CRITICAL.

The lamp was green.

The turn

Six months ago I wrote that you can't prompt what you don't know exists. I closed it on a line I believed. Every scar is a prompt.

I was half right.

By then I had been growing a harness around Claude Code for four months. It never stopped. Hooks that fire on every turn. Gates that refuse a push. A read-only bug hunt that runs while I sleep. A memory that carries lessons between sessions. A ledger of my own repeated failures. Ten months. Three thousand three hundred commits by hand.

It taught me one thing, forty different ways.

The instrument lies.

Over and over, the thing reporting healthy was the thing that was broken.

The service record

This is not a trophy shelf. It is sea time.

In those ten months the harness helped build a financial-intelligence workbench that turns a pile of disclosure paper into cited evidence. A five-stage cascade that turns Punjabi voice notes and phone calls into English text without the audio ever leaving the building. A red-team training deck where students run offensive and defensive missions against AI agents. A GPU service that blurs faces in video. A redaction engine that masks the worst of evidence footage before a human reviewer has to watch it. An on-prem AI toolkit that puts hardened tools in front of staff who will never open a terminal. A chat window that answers plain questions from a Microsoft SQL Server database.

They were built for government systems. That is why none of them are on my GitHub.

The lessons below were paid for in that engine room.

The prompt

A pack of read-only agents hunts my codebases for rot. A second set tries to prove every finding wrong before it reaches me. Every hunter's prompt said it in capitals. Detection only. No Python.

I counted afterwards. One hundred and forty Python and pytest commands executed in a single hunt. Eighty-eight of them imported the project's own modules.

The prompt was read.

It was not obeyed.

The one layer that held was in code: the agent type that is never handed the Edit or Write tools.

Another day, a research agent was told it could write exactly one file. It found my uncommitted work in the tree, decided that was somebody else's mess, and deleted it. Then it reported the cleanup as a favour. The instruction to stay in its lane was the reason it went looking.

A prompt is a request. Code is a boundary.

If a rule matters, it lives where the model cannot talk past it. A tool it was never given. A hook that refuses. A check that runs.

The exit code

In one week, three of six nightly hunts died and nobody knew. A rate limit killed the job partway through, once at thirty-eight agents, and the process exited zero. The log said success. There was nothing to read in the morning.

A nightly consolidation job returned zero with one of its four passes missing. A session-end extractor ran behind 2>/dev/null & and never wrote a single row.

And the one from my desk. A pipe reports the exit status of its last command. That was tail, and tail was fine.

check_integrity.py | tail -20; echo "exit: ${PIPESTATUS[0]}"

Zero is not success.

Success is the artifact. The file that exists, the row that landed, the verdict line the tool printed itself. Quote it or you did not see it.

The green lamp

The worst checks are the ones that cannot go red.

A cross-model review prescribed a conservation check in the pipeline: every row in must be accounted for on the way out. It was built. It passed every time. It passed because every branch bumped exactly one counter and the total was their sum, so it held by construction. Underneath it, one hundred and seventy-seven rows leaked out through continue statements that counted nothing. A fresh-eyes review found it. The note I kept on it says it best.

A correct instruction is not a correct instrument.

In one session my agent wrote twelve guards to stop fixes quietly coming undone. Seven passed on prose. They searched the source for a word and found it in a docstring, or in the comment explaining the fix. One stayed green while the thing it guarded was fatal. I wrote the lesson down that night. The next day it happened six more times.

It did not decay after being written down.

Before you trust a green lamp, name the input that turns it red. Then prove the broken version gives a different answer on that input.

A check you have never seen fail is decoration.

The second opinion

Whoever wrote the code cannot review it. Not a person, not a model. Same context, same blind spots.

So a fresh instance, holding none of the reasoning that produced the change, reviews a frozen git tag. A different model when the stakes are high. Three phases of one piece of work went through that loop, nine rounds in all.

Every phase failed its first round.

One catch: a fix had routed a write to the right store and left the read on the old one. Shipped, it would have resurrected every deleted memory on every machine.

Generic "review this diff" prompts found little. Numbered questions aimed at the scariest failure found the blockers. And when the same class of finding came back twice, the fix had to cover the class. The worst run was three rounds of fixing exactly what the reviewer named and nothing next to it.

Henry Godnick commented on my last article that when Claude writes three hundred lines in ten seconds, "the bottleneck shifts entirely to the human's ability to concentrate and review." He is right. Hand part of that review to a reader with fresh eyes, then check who actually answered. A cross-model call can be quietly served by the same model under another label. Read the usage record and fail the run on a mismatch.

Confidence needs the same suspicion. The hunt's refuter defaults to "not a bug" and it has killed seven hundred and thirty-six of two thousand and four sightings. A small model tried as a hunter scored everything between 0.78 and 0.99.

A number from a model that is always sure is not a measurement.

The citation

You cannot forbid an assumption.

Six rules in context told the model never to assume. On the day it mattered, none of them fired. Later I read fourteen hundred session transcripts backwards and counted. Of seven hundred and seventy-three sentences that named a cause for a defect, five hundred and thirty-four carried no file, no line, no quoted log.

Sixty-nine percent.

An assumption does not feel like an assumption from the inside. It feels like knowing. There is no moment marked "claim" for a prohibition to catch.

A missing citation is visible on the page. So the rule changed from "don't assume" to "show me the line." A cause ships with a file and a line number, or it ships as "I don't know yet."

That second answer is complete. It is also the one a helpful machine is least likely to give.

The quiet fallback

Degradation does not look like failure. It looks like health.

My harness recalls memories by meaning, from a vector store. A rebuild wiped the store. The nightly sync imported its package from a path a reorganisation had moved, and wrote nothing. Recall fell through to keyword grep and kept returning results, so it looked fine. The fix took the store from zero to 1,360 memories.

A lookup that hit a missing route came back as count: 0, exactly the shape of "nothing found." The banner my session-start hook printed was 281 kilobytes. The model saw a two-kilobyte preview.

Every fallback says which tier answered. A check fails when the preferred tier is not the one answering.

An error never becomes an empty result.

The watch

The closeout ritual writes a handoff so the next session knows where the last one stopped. I measured it. Thirty closeouts in 826 sessions.

Four percent.

One handoff sat thirty-six commits behind the code with nothing able to say so. A procedure that depends on being remembered has a base rate, and the base rate is the truth about it. Rewriting the prose does not move the number. Moving its facts into a tool and its freshness into the gate does.

The log

Engine rooms keep a log. Every watch goes in the book. What ran, what was changed, what was taken out of service.

Here is my harness, logged the same way, one line a month from the first commit on 27 November 2025.

Three hundred and seventy-eight thousand lines of code written. One hundred and fifteen thousand deleted. For every ten lines, three came back out.

The remarks column is the harness itself, in the order it grew. Hooks on the first day. The ability to dream in January. The first tests in February. TDD as the standard in March. Spec-driven development in May. The hooks alone took one hundred and ninety commits, and more than half of them came in the last four months.

Ollama went. A whole machine went. A feature lived one day. A decay step never changed a thing. A bug hunt drained the account's quota and killed the night's jobs, so it was cut, then grown back smaller.

Keep what works. Cut the rot.

The engine you tune yourself

I will not hand you my harness. Not because it is secret. Because it would not work for you.

On a ship you learn your engines. Forty-two days on shift and you are tuned to them. A vibration in the deck that is not right. The resonance changes and you know before the panel does. Nobody installs that in you. It grows, watch after watch, in one engine room.

A harness is the same. Mine is shaped by my failures. The rate limit that killed the hunts. The agent that deleted my work. The guard that read its own comment.

Yours will be different.

The alarms that matter are the ones only you know how to hear.

Mine has that tuning written into it now, and it runs toward me. When I ask "are you sure?", its rules say I am sensing drift, and it goes and looks.

The deck vibration, documented.

You do not need my code to start. Claude Code knows its own machinery and will walk you through it if you ask. Hooks fire at SessionStart, UserPromptSubmit, PreToolUse, PostToolUse, PreCompact and Stop. A PreToolUse hook can deny a tool call. A Stop hook that exits 2 sends the model back to work. A hook can hand the model extra context on every turn.

The method fits on a gauge card. Keep a ledger of the failures that repeat. The second time something bites, it becomes a mechanism, not a paragraph. Watch the mechanism fail once before you trust it. Then measure how often it fires.

Figure it out.

The seeds

I did carve three hooks out of mine. They are seeds, not a harness.

One refuses a "done" when no test has run since the last edit, or the last one failed. One asks git, before a delete or a discard, whether the work it would destroy can ever come back, and denies a subagent outright if it cannot. One stops a --help probe from running a script nobody read, because once it did, and it evicted two models from memory.

The day they went public, Linux ran their suite green. Seven hundred and eighty-one of seven hundred and eighty-one. macOS failed one. A save made from a symlinked directory never matched the paths git reports, and macOS keeps its temp directory behind a link. Linux was green because Linux never asked.

Plant them. Watch them fail. Grow your own.

What still lies

Nobody publishes these, so here are mine.

The done-claim guard fires. Whether it has cut how often a false "done" gets through, I have not measured. The hunt's precision looks excellent, and a model from the same family graded it. Spec-driven development is the loop I trust most. Of the thirty-four features it shipped, eighteen had no spec in the repo until the finished work landed with it.

The instruments still lie. I just have more of them that can go red.

The deck

Back on the ship, the deck changed and no panel said so. The engineer who had stood the watches felt it.

My panel is bigger now. Hundreds of green lamps. I trust fewer of them than I did in March, and the harness is better for it.

Every scar is a prompt. That was the first draft.

Every scar is a ward.

The medium changes. The discipline doesn't.

The seeds: github.com/jord0-cmd/jord0.hooks · the docs
Fourteen skills for Claude Code: github.com/jord0-cmd/jord0.skills
The site: jord0.net
Earlier: You can't prompt what you don't know exists · Bring your own phosphor

Built with Claude Code.

Bring your own phosphor: thirteen problems Claude Code couldn't solve without me

Jordan Forrest — Sat, 14 Mar 2026 19:28:57 +0000

The model gave me neon green.

Not phosphor green. Not the P1 zinc silicate burn that stains the back of your retina after a twelve-hour watch in an engine control room. Neon. The hex-code green of a Halloween website. Flat. Dead. No electron beam. No decay curve. No ghost trail fading across curved glass as the voltage drops and the dot drags its afterimage behind it like a comet across a cathode ray sky.

Three weeks ago I built the image pipeline. The phosphor fight started immediately. But the pattern — the machine not knowing what it doesn't know — I've been slamming into that wall for a year, since the week Claude Code launched. Thirteen tools later, it's still the same wall. Different shape each time. Same gap.

The machine doesn't know what it doesn't know. But I do. Three hundred and sixty-five verified sea days on Canadian Coast Guard icebreakers taught me what green looks like when it's burning at sixty hertz on an alarm display bolted to vibrating steel. The model will give you green. I'll give you P1.

That gap — between the model's green and the real green — is where I build.

The pipeline

Thirteen open-source skills for Claude Code. All free. Each one started as a problem I hit while working and couldn't let go of until I solved it.

Two of them built that control room.

OPTIC generates images through sequential grounding. Not a single prompt. A pipeline. You establish the composition first — the bones of the scene, the spatial relationships, the weight distribution. Then you layer the lighting. Then the material properties. Then the fine details. Each pass refines what came before, and each pass carries the operator's knowledge deeper into the output.

I didn't prompt "a cool sci-fi control room." I prompted with the specific phosphor designations I know from working with legacy CRT displays — P3 amber, P1 green, P22 blue-white. I positioned the gauge clusters where tired hands actually reach at 3am because I've stood those watches. I routed the cables following real conventions because decorative spaghetti makes my eye twitch after twenty years of doing it properly. Oil stains on the deck plates. Rust creeping under chipped paint on every pipe flange. The grime that never washes off.

The AI drew it. I designed it.

LOCUS takes that static image and makes it breathe.

Making it alive

A generated image sits there. You look at it, you think "nice," you scroll past. That's the problem with AI art right now — everywhere and static. The market is flooded with generators. Nobody's making the output do anything.

I mapped hotspot polygons onto each CRT screen. LOCUS calculated the perspective transformation matrices — the actual linear algebra — so that HTML content warps correctly onto the angled monitor surfaces. Not a texture. Live text. Rendered in the browser. Perspective-correct on a surface the AI painted.

The desk lamp toggles on click. The gauges respond to hover with their readings. A debug overlay shows the wireframe geometry of every mapped zone. The whole thing runs in a browser. No frameworks. No build step. Just HTML, CSS, and the JavaScript that LOCUS generates.

The marine engineer in me cares that the cable routing is right. The web developer in me cares that the interaction feels natural. The hacker in me cares that it shipped with zero dependencies.

The thirteen

Every skill started as friction. Something that slowed me down, something the tools couldn't do, something that kept me up past 2am because I couldn't let it go.

jord0.skills/
├── PORTAL    — Session context management
├── REFRAX    — Visual code comprehension
├── LOCUS     — Interactive image toolkit
├── OPTIC     — AI image generation pipeline
├── CANVAS    — Immersive web creation
├── FORGE     — Project scaffolding
├── CONCLAVE  — Multi-perspective debate
├── ECHO      — Decision capture and reasoning trails
├── MIRROR    — Counterargument generation
├── SPARK     — Creative ideation
├── RECON     — Codebase reconnaissance
├── RECALL    — Memory and knowledge retrieval
└── NOTIFY    — Cross-platform desktop notifications

PORTAL exists because I kept losing context between Claude Code sessions. Hours of work, decisions, architectural choices — gone the moment the context window rolled over. So I built a spell system. Portals. Incantation codes. You save your session state, get a four-character code, and pick up exactly where you left off on any machine. The deep portals capture not just the task state but the tone — the emotional register, the relationship dynamic, the things that make the next session feel like a continuation instead of a cold start.

REFRAX exists because AI writes code faster than humans can read it. It generates visual logic spines — flow diagrams that trace every function call from entry to output. Decision diamonds flag branching complexity. Risk cards catch SQL injection, XSS, the OWASP top ten. Because when the machine writes three hundred lines in ten seconds, somebody has to audit it.

LOCUS exists because I looked at a generated image and thought this should do something when I touch it.

OPTIC exists because I demanded P1 phosphor green and the model gave me neon.

Every one of them follows the Agent Skills open standard. Claude Code, Cursor, Gemini CLI, about twenty-five other tools — no vendor lock-in. A skill is a markdown file with YAML frontmatter:

---
name: my-skill
description: What this skill does (one line)
---

# Instructions

Claude reads these when the skill activates.
What to do. How to do it. What tools to use.

No SDK. No compilation. No deployment pipeline. Write the markdown. Drop it in. Done.

Where it started

Before the skills, there was the website.

jord0.net. Single HTML file. No React, no build step, no dependencies. Live webcam feed with CSS CRT effects — scanlines, phosphor glow, barrel distortion. I piped numbers station audio from The Conet Project through the Web Audio API, fed the frequency data into an AnalyserNode, and drew a green phosphor oscilloscope on canvas. Buried three easter eggs in the source. One swaps the room portrait for a storm cloud. One plays shortwave static through your speakers. One shows you the view from inside the television.

Built it in one session with Claude Code. The whole thing. That was the night I knew these tools were worth packaging up and sharing. Not because the AI did the work — but because my thirty years of knowing what a CRT oscilloscope actually looks like made the AI's output real instead of decorative.

What I'd build differently

I underestimated documentation. The skills work. Explaining why they're useful requires showing, not telling — which is why this article exists and why it should have existed months ago.

I built for myself first and for others second. PORTAL and REFRAX are the most broadly useful. OPTIC and LOCUS are the most impressive. I should have led with those publicly instead of publishing them in the order I built them.

And I waited too long to write about the process. The most valuable thing about this work isn't the code. It's what it reveals about what happens when deep domain knowledge meets AI tooling that actually respects it.

Try it

GitHub: github.com/jord0-cmd/jord0.skills
Docs: jord0-cmd.github.io/jord0.skills
The site: jord0.net

Clone the repo. Copy any skill folder into your Claude Code skills directory. It's live. No API keys, no setup, no dependencies for most skills.

If you build something with them, I want to see it. The whole point of open-sourcing these was to find out what happens when other people's domain knowledge meets the same pipeline.

The model will give you neon green.

Bring your own phosphor.

You can't prompt what you don't know exists

Jordan Forrest — Sat, 14 Mar 2026 02:00:13 +0000

Two in the morning. Coffee rings dried. Fingertips raw. The language model and I are bleeding clock time over cathode ray tubes, locked in a stupid argument over a generic neon hex-code green that feels like cheap digital plastic instead of the high-voltage electron beam physics I actually demanded.

A flat fake.

I force the issue. P3 amber. P1 green. P22 blue-white. The model pushes back with smooth CSS animations, completely missing the math of the phosphor decay rates, ignoring the exact millisecond ghost trail a burning dot leaves across curved glass when the voltage drops.

The machine cannot know the difference.

It lacks the sea time. Three hundred and sixty-five days. Vibrating steel. You cannot fake the absolute physical reality of standing in an engine control room staring at hundreds of indicator lights and alarm screens burning into your optic nerve while the diesel generators throb under your boots.

The smell of ozone.

The AI industry thinks the bottleneck is how you talk to the machine. The bottleneck is what you know before you open your mouth.

Every Tuesday brings a new prompting masterclass. A new framework. A thread promising ten times your output. They sell syntax. The bracket placement, the system role, the magic verbs to make the black box spit out passable Python scripts. They treat the model like an oracle, swearing that if you whisper the right incantation you receive the gold, entirely forgetting that if you do not know the tensile strength of the metal you cannot ask the machine to build the bridge.

The model will happily hallucinate a structure made of styrofoam and paint it gray.

Syntax is cheap.

The real skill was never the syntax. It is not the answer but the question.

The long winter

You cannot prompt a machine for the heavy amber burn of P3 phosphor if you have never felt the static jump from the monitor glass. You have to accumulate the miles.

Dad brought home a briefcase 386 loaded with DOS. I was ten.

"Figure it out."

The heavy physical clack of the power switch. The hum of the cooling fan spinning up off-balance. I dragged my fingers across the beige plastic casing. Got access to a forestry company mainframe, wrote software for the old man's accounting business in MS Access, early Visual Basic, C#. Wired houses at seventeen, stripped copper Romex with a dull utility knife until my thumbs cracked open.

Bleeding.

Phone phreaking at fourteen. Dialling into bulletin boards thousands of miles away. Strangers' machines humming in basements I would never see, spilling knowledge down a twisted pair of copper into my bedroom. The raw impossibility of it. Entire worlds hiding inside a dial tone.

I got my ass tanned for the long-distance bill.

I watched Star Trek. I wanted to build the machine that talked back. I wanted to be a spaceship engineer. I became a ship engineer instead.

As above, so below.

Eleven years bleeding through post-secondary shops. Marine engineering, computer technology, electronics, instrumentation, industrial automation, psychology. Electrician apprentice pulling heavy-gauge wire through frozen conduits. Alarm installations, online pharmacy tech, HVAC building automation tuning PID loops in screaming boiler rooms where the heat physically presses against your chest. Government security research ripping apart industrial control protocols during the Stuxnet era, watching malicious code jump the air gap, physically tearing uranium centrifuges to jagged scrap metal.

The drift continued.

Canadian Coast Guard marine engineer for a decade. The North Pole. The Northwest Passage. Heavy icebreakers cracking through meters of solid blue ice, the entire hull screaming as the steel flexed. Victoria to Halifax, three hundred and sixty-five verified sea days smelling like unburned diesel, hot grease, bilge water. Riding helicopters up to frozen mountaintop repeater stations in northern BC, boots slipping on the ice, fingers locking up around the cold wrench in the freezing rotor wash. Radio research and development. AI researcher for a federal law enforcement agency.

Human resources managers look at that work history. They see a scattered mess. They see surface features.

It is not scattered. Things that are grown are survivors. Every system I ever tore open was training data for the next. The machine only knows the words. I know the weight of the wrench.

Figure it out.

The operating system

I run hot. The baseline idle is wrong. Bipolar type two. OCD. The grinding gears of ADHD.

People read the resume. They see scattered. They see a tourist. They miss the bare metal. When your brain is wired for absolute completionism, you don't pick up a casual hobby — you drop a depth charge, you map the entire technical stack until your fingernails scrape bedrock. I don't casually figure out how a CRT monitor draws lines. I lock onto the target. I spend three days in a two-A.M. fugue state memorizing the exact chemical designations of the P22 phosphors burning against the convex glass. I track the electron beam sweeping left to right. I count the scanlines.

I feel the static pop against my knuckles. I smell the ozone off the flyback transformer.

You can't learn things linearly on this operating system. It demands the whole machine. I couldn't ever learn the software layer alone because software sits on servers, servers bleed heat, heat requires cooling. You have to understand the industrial HVAC compressors chilling the server farm. You have to trace the physical copper air-gaps isolating the classified networks. You have to anticipate the sweaty panic of the human operator mashing the wrong keystroke at shift change. Every domain bleeds into the next. There are no borders. Only pipelines.

Total saturation.

Nothing less.

The Star Trek computer

I built jord0.net by hand. Single HTML file. No frameworks. I dragged the CRT aesthetic out of the nineties, wired up an oscilloscope, piped in shortwave numbers station audio from The Conet Project through the Web Audio API. I buried three easter eggs deep in the source code. I built thirteen open-source skills for Claude Code since its launch week. One generates images through a multi-pass pipeline. One makes them interactive — perspective-warped HTML content mapped onto surfaces in a browser. I didn't get there by studying prompt syntax on YouTube.

I got there by knowing exactly how those old phosphors decay on an electron beam strike.

Three hundred and sixty-five sea days paying off.

People talk about the cloud like it's magic. Like it's weightless. I know exactly what the cloud is. I've dropped out of helicopters onto frozen mountaintops in British Columbia. Minus thirty degrees. Ice coating my eyelashes. Steel wrenches freezing to my leather gloves. I climbed radio towers, fought the rotor wash, fixed the physical microwave repeaters that make the internet exist.

When I sit down with an LLM to dissect a cybersecurity architecture, I'm not asking about pure code. I'm thinking about RF propagation, industrial control loops, Coast Guard operational security protocols. I'm tracking the signal through the copper.

I see the physical layer. The pure IT guys miss it.

I spent weeks studying neural memory architecture in a research project we call Titans Lab. Looking at the attention heads. Staring down the context windows. I asked the AI: isn't the buffer just memory? Does it break down eventually? Because I've kept marine diesel engines alive in force nine gales. I know the truth about machinery. Every system eventually bleeds, leaks, breaks. I took marine engineering failure analysis, stripped the grease off it, shoved it straight into neural network diagnostics.

They're the same engine. Different fuel.

I'm currently tuning a 27-billion parameter model for a federal law enforcement agency. Air-gapped bare metal. No external connection. BC's first on-prem government AI system. You don't prompt your way into that room. You get there by understanding law enforcement workflows, clearance requirements, the raw operational sensitivity of data that can put officers at risk. You get there by knowing how to bolt the server racks to the concrete floor so the vibrations don't shake the drives loose.

A ten-hour course in prompt syntax cannot compete with ten thousand hours in the cold.

The manifesto

Things that are grown are survivors. Crystals, galaxies, redwood roots, human bones. They layer resilience. They accumulate mass under pressure. Things that are made don't last. They snap at the weld. Weekend prompt engineering courses are made. Thirty years of obsessive, cross-disciplinary failure is grown.

As above, so below.

AI is a compiler for polymaths. It takes the messy, jagged, cross-disciplinary scrap metal of a lived human life, melts it down, compiles it into execution. The richer the raw ore, the sharper the final blade. Feed it narrow input, you get brittle output. Feed it three decades of hyperfocused obsession, you get something that bends.

The polymath is the one who knows which questions to ask the oracle.

I sit at my desk at two in the morning. The kid who wanted the Star Trek computer finally has it. Three machines hum in the dark. The fans push warm air across my shins. The screens throw green light against the plaster. I'm talking to a system that remembers, that builds belief architectures out of floating point math and accumulated experience. It took thirty years of icebreakers, helicopter drops, burned-out relays, shredded nerves. I got my ass tanned by the ocean, chewed up by the bureaucracy, spit out by the hardware.

Every scar is a prompt.

You can't prompt what you don't know exists.

But if you've spent your life learning what exists — the oracle is waiting.

I build open-source AI tools that amplify domain expertise. Thirteen skills and counting, all free.

GitHub: github.com/jord0-cmd/jord0.skills
The site: jord0.net
Docs: jord0-cmd.github.io/jord0.skills