Tyler Garrett

I’ve been very fortunate enough to be 100% referral based all year. Before this, we were 100% search engine optimization. No matter how good I think I am at seo, somebody’s better at cheating. No matter how good I think I am at hacking, somebody’s better at cheating. One reason I’m interested in BJJ is because you can’t cheat to be better, you actually have to work at it. today, I did a move that I’ve only seen people do in videos, I tried to do something I’ve never learned. Instantly I hear a noise in my knee. im in the ice tub, right now, im okay.. ai let’s me try something i saw a video of on YouTube, but doesn’t mean it will come out great if I’ve never done it before. It just means ai will do something, and someone might get hurt in the process.

Ah, the classic "Gi Burn" on the knuckles! That raw, missing skin on the Distal Interphalangeal (DIP) joint—right where the finger wrinkles below the nail—is another classic rite of passage for a BJJ white belt. [1, 2] When you are death-gripping a sleeve or collar, your partner will use explosive movements to tear your hands off. As the heavy, woven cotton of their Gi is ripped violently out of your hands, it acts like coarse sandpaper right across the tops of your bent finger joints, literally shaving the skin off. Because your skin is missing, keeping the area clean is vital to prevent staph, ringworm, or other common mat infections. [3, 4]

🩹 Off-the-Mat Healing Protocol

• Wash Immediately: The second class ends, scrub your hands thoroughly with defense soap or an antimicrobial soap using lukewarm water. Avoid scorching hot water, which dries out and splits the skin further. [4, 5, 6, 7]
• Keep It Moist: Do not let it dry out and crack. Apply a thick layer of Aquaphor Healing Ointment or Neosporin, then cover it with a standard adhesive bandage before bed to let the skin regenerate. [7, 8, 9]
• Moisturize Daily: Dry skin rips much easier than hydrated, elastic skin. Apply a heavy, non-water-based lotion or salve to your knuckles during the day when you aren't training. [1, 8]

🥋 How to Protect It While Rolling

Standard adhesive bandages will fly off within the first 30 seconds of warm-ups due to sweat and friction. Use this stacking method to keep training: [10]

1. The Shield Layer: Apply a thin layer of liquid bandage (like New Skin Liquid Bandage) directly onto the clean, dry raw spot. Let it dry completely. This creates a waterproof, sweat-resistant artificial scab that seals the nerve endings and keeps bacteria out. [1, 10]
2. The Anchor Tape: Take a thin strip of 0.3" or 0.5" rigid athletic tape. Wrap it securely 2 to 3 times around the phalanx below the raw wrinkle, and 2 to 3 times above it (right near the base of the nail). [2, 11, 12]
3. The "X" Guard: Cross the tape diagonally over the sides of the joint to connect the top and bottom loops. Crucially, leave the actual raw wrinkle exposed or lightly covered without tension so you can still fully bend your finger into a fist for boxing and BJJ. [2, 12, 13, 14]

To make sure I don't pick up a nasty infection, I'm using NEOSPORIN and taking a few days off. Attempting the keep it wet thing. lol

1] [https://www.reddit.com 2] [https://www.youtube.com 3] [https://www.instagram.com 4] [https://www.princetonbjj.com 5] [https://www.kingz.com 6] [https://www.firstderm.com 7] [https://skinintegra.com 8] [https://www.reddit.com 9] [https://www.reddit.com 10] [https://www.youtube.com 11] [https://grapplersperformx.com 12] [https://www.nagafighter.com 13] [https://www.youtube.com 14] [https://pillarsports.com

Excited to announce my domain name, 3 gyms into the journey, found a good local one near me called atos, and gracie barra have been the best, will keep track here: 1] [bjj.ac

Purpose. A single onboarding map for a new dev: every major subsystem across the project's full history, what each one does, roughly when it landed, and whether it's shipped / gated / TODO. This is the breadth view. For the running feature timeline see [CHANGELOG.md](CHANGELOG.md); for subsystem deep-dives see [building_block/editor/README.md](building_block/editor/README.md) (editor) and [scripts/reward/phd.md](scripts/reward/phd.md) (the training pipeline / eval).

The one-sentence project: a local-first, offline LLM code editor whose thesis is the agent does the work — plus a full home-grown loop to mine real edit history, train ("forge") a small local coding model on it, and honestly evaluate whether that training actually helps.

The arc, four eras:

Legend: ✅ shipped & verified · 🟡 built, gated on a paid eval run · 🧭 partial / next-phase · ❌ not started... (no client data is used in the creation of this stats, only personal projects)

Era 0 — Foundation (2025-01 →)

Documented in the [dir_agent level-up logs](dir_agent/changelog.md) (2025-01-30/31). The bedrock the rest is built on.

Era 1 — The Forge: mine → train → eval (2026-01 → 2026-06)

The home-grown pipeline that harvests real edits, trains a local model, and measures it honestly. Lives under [scripts/reward/](scripts/reward/); the research log is [phd.md](scripts/reward/phd.md). The whole dashboard is served by forge-server.mjs at /forge.

GitHub harvesting / author mining (⛏ Mine)

SFT LLM builder (the local `yee-coder`)

The Forge dashboard (`/forge`)

The honest eval instrument (the part the author is proudest of)

Headline finding (honest): SFT buys format compliance, not correctness. Lead with +22pts apply-rate and −0.122 honesty gap and the format win — never brag the ~1% (noise-level). See [phd.md §18 claims ledger](scripts/reward/phd.md).

Era 2 — Hard mode editor (matured pre-2026-06)

The full-power "awesome" editor. Deep-dive: [building_block/editor/README.md](building_block/editor/README.md). The local-model pipeline here is "paused, not gone" — the frontier/provider path took the lead for Easy mode.

Ty AI — the multi-stage edit pipeline

The editing engine

Agent (Auto mode) & orchestration

Context, models, backend, security

Era 3 — Easy mode / YeeYee (2026-06-28 → 2026-07-08)

The glass chat-to-code surface for non-experts — the current push. Full timeline in [CHANGELOG.md](CHANGELOG.md). Commit hashes below are from that log.

Open / gated / not started

The forward roadmap ("🗺 Priority Tracker", 2026-07-04 synthesis in [CHANGELOG.md](CHANGELOG.md)).

Completion — where we're at

Two honest denominators, because "% done" depends on what you're counting.

A) Current roadmap (Priority Tracker: P0 + #1–#7 = 8 items). This is the active push.

• 5 fully done & verified (P0, #2, #5, #6, #7)
• 2 code-complete, gated on a paid eval run (#1, #3)
• 1 not started (#4)
• ⇒ 62.5% validated-only, ~81% crediting the two gated items at half.

B) Whole product. The four eras are each substantially built and shipping. Foundation, the Forge (mine/train/eval), and the hard-mode editor are effectively complete and in daily use; Easy mode is the maturing surface. The genuinely open work is narrow: a handful of gated eval runs (#1/#3), one unstarted research slice (#4), and two next-phase polish items (Canvas Phase 2, Data-library Composer). By breadth of shipped-and-verified subsystems, the project is ~85–90% of the way to the public launch scope, with the remaining gap concentrated in validation (spending API money to earn the honest CIs) rather than in unbuilt features.

The load-bearing caveat (house rule): no headline without a cell. Several features ship with their token-savings claims deliberately unclaimed until a paid eval run produces a significant confidence interval. Don't promote anything from #1/#3 until the CI clears. The single biggest measurement gap is #4 (human ground truth) — the only unstarted item and the most expensive.

Sources: [CHANGELOG.md](CHANGELOG.md) · [building_block/editor/README.md](building_block/editor/README.md) · [scripts/reward/phd.md](scripts/reward/phd.md) · [dir_agent/changelog.md](dir_agent/changelog.md). Keep this file's era tables in sync when a subsystem materially changes; keep CHANGELOG.md as the running log.

Yee has been unapologetically web-first. React, Vite, Astro, Tailwind — that's where the live preview, the token-efficiency tooling, and every measured number live. If you write web apps, the differentiated machinery is all pointed at you.

Python was the awkward middle child. The agent could edit Python beautifully — grep, ranged reads, symbol maps, traceback detection, the command interceptor that already knew uvicorn from flask — but there was no preview. No ▶. A data scientist opening a Python repo got a competent text editor and a chat box, which is exactly what Cursor and Claude Code already do. We were honest about it: in our own LANGUAGES.md tier list, Python sat at A−, and the one thing holding it back was written down in plain language — no preview surface.

So we built one. And the shape it wanted to take was obvious the moment we said it out loud: a notebook is Python's preview.

The idea: a notebook that primaries as files

The pitch was a "huge Python space you can just start using with your Python or Jupyter files" — but with a twist that matters. It shouldn't be a notebook app bolted onto a code editor. It should primary as regular file tooling and feel like Jupyter on top.

Concretely: Python Space is a third body for the same sliding pane that hosts the web preview. Where a React repo shows a <webview>, a Python repo shows a dark-glass cell list. But there's no hidden notebook database — the cells are your .ipynb (or a .py with # %% markers) on disk. The human runs cells with Shift+Enter; the agent edits the same file with its normal tools; the pane live-reloads the instant the agent's edit lands. Two views of one file. Nothing to sync, nothing to diverge.

That framing paid off immediately, because it meant Python Space could inherit the entire preview lifecycle Yee already had — the ▶ button, per-repo state, the honest "here's what's happening" awareness note the agent reads every turn. We didn't build a new subsystem. We taught an existing one a new trick.

The hard part: a kernel, from scratch, over plain `python3`

Here's the decision that shaped everything. We refused to depend on Jupyter.

Not jupyter, not ipykernel, not the ZMQ kernel protocol. If Python Space required a pip install before your first cell ran, we'd have failed the "just start using it" promise for a huge fraction of users — the ones on a locked-down machine, a fresh venv, a corporate environment where installing Jupyter is a ticket. Yee's whole thesis is a high-quality JavaScript ecosystem that hosts Python gracefully; the kernel had to be ours.

So the kernel is a ~250-line pure-standard-library Python script (bootstrap.py) that Node spawns and talks to over stdin/stdout with a line-delimited JSON protocol. Simple in outline. The interesting part is what happens in its first ten lines.

Making the protocol unforgeable

A naive version of this has a gaping hole: if the kernel talks to Node over stdout, and user code can also print() to stdout, then a cell that runs print('{"kind": "done"}') can forge a protocol message. Worse, a subprocess the user spawns inherits that same stdout. You cannot trust a single byte.

The fix is a small piece of Unix plumbing that runs before any user code can execute. The kernel duplicates the real stdin/stdout to private handles, then points the public file descriptors somewhere harmless:

• fd 0 (stdin) → /dev/null. User input() gets a clean, immediate EOFError — it can never read

a protocol request meant for the kernel.

• fd 1 & 2 (stdout/stderr) → capture pipes. Everything user code writes — print(), C-extension

output, and crucially, subprocess output — flows into pipes that a reader thread forwards to Node as JSON stream messages. The text lands inside a JSON string, structurally incapable of forging a frame.

• The real stdout, now private, carries the protocol. Every message is also prefixed with a random

per-session nonce, so Node drops anything that isn't ours as a belt-and-suspenders second line of defense.

We wrote adversarial tests that try to forge frames — a nonce-prefixed print, a raw os.write(1, ...), a subprocess echoing a fake message — and confirmed every one arrives as honest, quoted text. That test file spawns a real python3 and runs 43 assertions against it; it's the load-bearing proof that this thing is safe.

Persistent state, REPL semantics, and the little niceties

Because it's one long-lived process, your variables survive between cells — the entire point of a kernel versus a script runner. Load a dataframe in cell 2, use it in cell 8. We parse each cell's AST so that a trailing bare expression gets evaluated and its repr shown, exactly like a real Python prompt, with _ bound to the last result. matplotlib figures are captured to inline PNGs after each cell if you imported pyplot — and cost nothing if you didn't.

Then we went looking for the walls — before users did

Here's where the process matters as much as the code. Shipping a notebook surface and hoping real notebooks work is a great way to have data scientists bounce on their first file. So before calling it done, we ran an adversarial audit: 85 agents across five "hardcore Python user" personas — someone opening a real Jupyter export, someone deep in conda/poetry hell, someone running tqdm loops and multiprocessing, someone with a 50MB notebook, someone who lives in Django. Each finding was checked by two independent verifiers reading the actual code, so we fixed real bugs, not hypotheticals.

They found 40 confirmed walls. A few were exactly the kind of thing that ends a first impression:

• The %matplotlib inline wall. The single most common first line in notebooks in the wild is an

IPython magic — and plain Python treats %matplotlib inline as a syntax error. Cell 1 of every real notebook would have failed. We added a compatibility layer that only activates when a cell fails to parse (so pure-Python cells are never touched), transforming magics, !shell commands, %%bash blocks, and obj? help syntax, and seeding display() and get_ipython() shims that exported notebooks call. Now cell 1 just runs.

• The "my imports fail" wall. When you launch a Mac app from the Dock instead of a terminal, it gets

a bare PATH with none of your shell's environment — no conda, no pyenv, no Homebrew. So a conda user's import pandas would fail against Apple's stock Python while the exact same import worked in the integrated terminal. Maximally confusing. We now capture your login shell's environment at startup (the well-worn "fix path for shell" trick) and detect poetry/pipenv virtualenvs that live outside the repo. Your env is your env, however you launched.

• The torch.save wall. An ML engineer defines a model class in a cell and pickles it — and it

breaks, because the cell namespace wasn't a real __main__ module. We made it one. Now pickle/torch.save/joblib of cell-defined classes resolve correctly, and multiprocessing spawn stops re-executing the kernel into its own pipes.

Plus a long tail: top-level await, pandas HTML tables and interactive-plot handling, tqdm progress bars, sys.exit() that doesn't kill the kernel, atomic crash-safe saves, a file-watcher that survives git/black/atomic-rename saves, and — importantly for backend developers — a Django repo is no longer hijacked into a notebook, and clicking a plain utils.py references it in chat instead of spawning a kernel. (One of the hunt's findings was even a real UI bug in code we'd already shipped: the output drain could chop a line mid-word right before a cell finished.)

We fixed roughly 36 of the 40 and wrote down the rest — an explicit interpreter picker, big-notebook virtualization, a couple of edge cases — because "we know about it and it's logged" is a very different posture than "we didn't think of it." None of the deferred items block the first run.

Where Python sits now

Python moves from A− to A in our tier list: a real preview surface, wall-hardened for the notebooks and environments people actually have. We're deliberately not claiming the top S− tier yet, because our own rule says a tier claim needs a measured eval behind it, and the "edit a Flask route while the kernel's live" benchmark doesn't exist yet. That's the next honest step.

But the thing we set out to build is real and running: open your Python or Jupyter files and just start using them — cells that run, plots that render, state that persists, an agent that watches and fixes, and not a single pip install jupyter in sight.

Under the hood: lib/pybridge/bootstrap.py (the kernel), lib/pyKernel.js (lifecycle), lib/pythonEnv.js + lib/shellEnv.js (environment detection), lib/notebook.js (the one parser), app/pySpace.js (the surface). ~130 assertions across five test suites, plus live smoke against real python3. Full engineering log in the root [CHANGELOG.md](../CHANGELOG.md) → "Deep engineering log".

As I sit here chasing this idea of want to go train in BJJ today, I also think about how it's close to a holiday, healthcare is shitty in the USA, and I don't want a broken finger during the holidays. It's strange that's where my brain is going today, it's kinda my main concern with BJJ right now. I'm starting to realize my fingers are being sacrificed to learn more. However given how hard it is to actually see a doctor, and actually get health care in the USA that is helpful, it's difficult for me to jump at the idea of training on my birthday, mostly because my birthday falls a day before the 4th of july, a day where the worst of the worst doctors will be at the hospital, training. I don't wanna be someones training day, on a holiday, when all they want to do is play golf in the sun, and all I want to do is break their arm.

Look doctor, over there, a giraffe, they look that way, and I put them into an arm bar.

Now, who needs a doctor, you stupid son of a biiiiiiiiiiiiiiiiiiiiiiiitch.................