Unformed Delta - everything

Inkhaven is two events stabled into one

Thu, 30 Apr 2026 23:25:00 +0000

More to add here later + some editing, but the Closing Ceremony is about to start, so I’m going ahead and publishing this in its unfinished state for now!

Inkhaven is at least two different events stapled into one.

Commitment Mechanism

Publish a post every day or perish.

This is what attracted me to Inkhaven. I did The 6% Club to try to kick start a blogging habit, breaking through my fear of publishing. It kind of worked, but I still wasn’t able to publish the “harder pieces” I wanted to, and only published irregularly.

It worked, but not in the way that I expected. When I managed to publish before, I usually would sit down for a few hours, and end up with a finished post. For the posts I never ended up getting to, I assumed that my problem was just lack of motivation. With a hard deadline, I was certain I’d find the motivation to just grind out the harder posts.

Early on in Inkhaven I tried this, but either ended up failing and needing to pivot, or publishing an imperfect version of the idea inside of my head.

At first this made me feel like a failure. But over the course of the month, I found time to continue to revisit the same ideas.

Some of the ideas ended up eluding me the entire month¹. Other ideas just took longer than I expected². And sometimes I managed to publish a follow up that more clearly expressed the idea³. Publishing even something mediocre about the ideas I care about it easier to come back to them.

The most valuable lesson for me from the commitment mechanism was the value of setting aside time to write. Though I still get writers block for specific ideas, I find it a lot easier to sit down with the intention to write. And doing that helps me think about and research my more difficult ideas.

Writing Residency

Mentorship opportunities from celebrated writers, craft-honing workshops, and professional feedback.

Inkhaven provides an all you can eat buffet of feedback and workshops. This was strongly in tension with the daily publishing requirement for me. While the daily commitment mechanism was helping me overcome my perfectionism, the focus on better writing

Much more so than the previous cohort, it was very common for residents to publish at the last minute. I only managed to publish 5 posts before 6pm, and 9 before 10pm⁴.

Because I was consistently cutting it close, I was rarely in a position to get feedback on my posts before publishing them. When I did manage to, it helped me improve the quality of my posts or at least made me feel better about publishing.

I was also able to get feedback after publishing, but doing so usually felt less meaningful than getting it ahead of time. Because of the daily publishing requirement, it felt hard to justify going back and improving pieces that I had already published. I still found it useful to think about for my future writing. Plus, maybe I’ll go back and improve the pieces using the feedback after Inkhaven.

The workshops were lower friction, and I found them a useful distraction when I was having trouble focusing on writing.

I want to shout out Justis Mills for reading most of the blog posts for over half of the residents and giving higher level feedback on “Blog Gestalt”. I found this really useful for thinking about what direction I want to take my writing in the future.

I aspire to make UnformedDelta a public archive of my notes similar https://gwern.net. With Gwern’s encouragement, I managed to publish ~50 of my existing unrefined notes in addition to my daily posts in the latter half of this month, while overcoming my perfectionism that was holding me back from publishing them.

Community

I don’t have anything fancy sounding to put here.

There’s also kind of a 3rd event. Inkhaven is meetup of particularly writing oriented rationalist-adjacent writers.

I’m proud to have organized an evening playing board games, an outing to see Project Hail Mary, and a trip into the city to try Wildtype Salmon.

After failing to write “Code is communication”, I refined my thesis to “Code that is grown” but even after writing and trying to express my thoughts for hours I still wasn’t able to publish by the end of the month. (Stay tuned, I still want to write this post Inkhaven.) ↩
My article comparing WaniKani and jpdb.io which broke my The 6% Club publishing streak in September turned into a 3 article series: ↩
In some the introduction I wrote for programming language features (and optimizations) is follow up to an expressive programming language, more clearly expressing why I care about expressivity of programming languages. This still isn’t perfect but designing my ideal programming language is a big project. ↩
11 posts after 11:30pm, and 5 posts after 11:45pm, ouch! ↩

Why I'm building my own knowledge management system

Thu, 30 Apr 2026 06:50:00 +0000

File systems are the default categorization system for personal information on a computer. They make it easy to store files, notes, repositories, or whatever in hierarchies.

But hierarchies are limiting. A file can only exist at a single path¹.

Information in our minds doesn’t work like this. When speaking we reference the same entity in lots of different ways. Whether I have a layover in “San Francisco”, am going to “the airport” to fly home, or am entering “SFO” on Google Flights to book a ticket, I’m referencing the same entity.

Symlinks try to achieve this, but are fragile. If the original copy moves the symlink breaks and it is often isn’t easy to find the original copy.

Hardlinks are closer you map multiple paths to the same underlying data. However, hardlinks suffer from challenging edge cases, and generally don’t support directories.

The internet promised to solve this problem. Hyperlinks let people reference and categorize things however they want, right?

Take YouTube for example. It’s trivial to create a playlist of videos. If you want to categorize your playlists into a hierarchy, YouTube won’t let you do that, you just need to save them into a folder of bookmarks, or as links in a note.

Personal knowledge management tools like Notion, Obsidian, Logseq, or Roam Research attempt to make keeping bookmarks, links, notes, and research easier. These are great, I use my Zettelkasten of markdown notes with Obsidian sometimes².

These systems make me sad that I can’t associate metadata with arbitrary data — YouTube videos, Wikipedia articles, songs, and so on. Often they support fancier features like canvases, PDF clippings, and even database like rows, once you leave the domain of markdown, metadata starts being stored in private formats.

But I find it too risky to invest heavily into these systems, because building or maintaining a replacement that supports whatever custom features I use would be non-trivial.

What I really want is a personal ontology that operates like Wikidata. I hope that Web3 (not the crypto kind) projects like Solid are steps in this direction, but they’re still very immature, and I don’t want to couple myself to shifting standards.

Pretty much the only satisfying option seems to be building it from scratch myself.

When I was ~10 I remember my uncle asking me how I thought my brain worked. I described it as a point of light bouncing around a network of memories.

I’m hoping that someday I can bring that network of connections into the real world and interact with my computer the same way I interact with my mind.

I want to build a system in which my mind can wander safely to the information it wants, while knowing that it contains only information that I put or chose to be there. Perhaps someday I will achieve this dream.

↩
In practice, I mostly edit my notes using Neovim with custom language server for completion, transclusion, and jumping to links. ↩

problems with hardlinks

Thu, 30 Apr 2026 04:51:00 +0000

This is for tracking various problems with hardlinks.

Common filesystem system operations can break hardlinks

A common way to atomically modify a file is to make changes to a copy, then moving the copy to replace the original. This breaks hard links. The copy has a separate inode number and moving it only replaces the targeted path, not both.

You can easily replicate this behavior as follows:

echo 'foo' >foo.txt
echo 'bar' >bar.txt
ln foo.txt hardlink.txt
echo 'The hardlink works' >hardlink.txt
cat foo.txt hardlink.txt
# The hardlink works
# The hardlink works

Then doing:

echo 'Replacement' >replacement.txt
mv replacement.txt hardlink.txt
cat foo.txt hardlink.txt
# The hardlink works
# Replacement

hardlinks

Thu, 30 Apr 2026 04:48:00 +0000

A way of having two files that reference the same underlying data, such that modifying one modifies the other.

In the context of file system implementation, technically a hardlink is just a directory entry associating a name with an inode. Every addressable file has at least one, but in colloquial usage it’s more common to only talk about hardlinks when there are multiple for a single inode.

Most file systems support file hardlinks, associating multiple paths to a single inode. Using file hardlinks is fairly brittle.

Directory hardlinks usually aren’t supported because they create directory cycles, and most tools that traverse file systems assume a tree structure.

In macOS from OS 10.5 HFS+ supported directory hardlinks and used them for Time Machine. It was possible though risky to create directory hardlinks using the syscall api. APFS removed support for hardlinks in favor of APFS clones.

For even a bad pause

Wed, 29 Apr 2026 06:51:00 +0000

Even a global treaty pausing all new training of frontier AI models, would leave a lot of room for existing models to continue to disrupt.

Our existing workflows weren’t designed with AI agents in mind and there’s abundant low hanging fruit for optimization. Every time I use Codex or Claude Code, I learn something new, and there’s plenty of things I just don’t have time to try.

Beyond code there’s plenty of other domains. Claude Cowork, the 10 folders of markdown files that caused the SaaSpocalypse, Claude Design, and more aren’t new models, they’re just harnesses for making it easier to work with existing ones.

What will be the impact on the economy once even our existing systems are widely adopted?

There’s a bunch of good things that we get for free by pausing AI progress.

The technology as it exists today would diffuse. The public lags behind what those of us interested in AI see.

More election cycles gives more opportunity for more informed and reasonable lawmakers to be elected. It also gives us room to negotiate and dream up better AI policies.

Nothing about pausing means AI safety research needs to stop. Who knows what novel problems or breakthroughs we might find in the next years?

Bernie Sanders and Alexandria Ocasio-Cortez’ AI Data Center Moratorium Act is just 1853 words — well worth reading all of.

Half of the bill is a sizzle reel of quotes from experts and industry leaders. The functional section of the bill is tiny:

154 words define “Artificial Intelligence Data Center”
287 words set the terms of the moratorium: no new AI data centers until AI is safe and built to be mutually beneficial for all Americans
275 words requisition various reports, and give the Secretary of Energy the power to verify that the moratorium is being followed
161 words ban the export of chips to countries not implementing similar measures

It’s a far cry from a global treaty. But it takes action now buying time and leverage to get a more comprehensive treaty implemented.

The bill cedes our largest advantage to China. Chinese models are only 3-9 months behind the US frontier, slowing down puts us at risk of losing the frontier.

This is costly, but perhaps might also serve as a signal. How can we better demonstrate our commitment to AI safety?

AI labs have frequently say that they want AI regulation. I also look at this bill as an invitation to the labs: help us figure out how to make AI mutually beneficial for society, and then you can go on building the data centers you want.

My largest quibble is with some of the most concrete details. To me one of the benefits of a sloppy pause are that it gives us time to contemplate what better legislation might look like. Enforcing that AI data center development be done with union labor while nice, seems far from necessary and I’d prefer a bill with less provisions about what is necessary to end the moratorium.

I’m confident that If Anyone Builds It, Everyone Dies. Will we be able to stop, or are the rewards from training better and better AI models too tempting? How long would it take us to stop even if policy makers unanimously agreed that we should?

Perhaps we should slow down as much as we can now.

Editor patterns for file modification

Tue, 28 Apr 2026 23:56:00 +0000

These are patterns that editors might use when writing changes to a file after editing it.

Truncate-and-rewrite. open(path, O_WRONLY|O_TRUNC), write(...), close().
Modify-in-place. Same as above but without truncating. Same considerations, but worse because it can cause corruption when editing simultaneously.
Write-tempfile-then-rename. open("path.tmp.XXX", O_WRONLY|O_CREAT), write(...), fsync(), close(), rename("path.tmp.XXX", "path") (e.g. vim)
Backup-rename-write. rename("path", "path~"), open("path", O_WRONLY|O_CREAT), write(...), close(), optionally unlink("path~") (e.g. vim with backupfile=no)
macOS-specific atomic replace. renamex_np() with RENAME_SWAP, or FSReplaceObject from the higher-level APIs. TextEdit, some Apple apps
In-place mmap edits.: (especially anything Electron-based with SQLite, or scientific data tools)
Lock files and dotfiles. Many editors create .path.lock, .~lock.path#, .path.swp, path.swo, etc.

First impressions of Lean

Tue, 28 Apr 2026 06:49:00 +0000

Since reading a perfectable programming language I started getting the itch to try actual dependently typed programming languages again.

Haskell is my favorite programming language because it provides one of the strongest type system but my most common frustrations in Haskell are from not having access to stronger types. Dependent types in Haskell are an active research project, but still far away. So when I’ve wanted more power I’ve had to make do with Coq (now Roqc) plus a little bit of dabbling in Idris and Agda.

In my usual fashion, I dove right in without reading the tutorial, hoping my experience with similar languages would take me far enough.

First steps

I started out by just typing out some definitions.

def x : Int := 1
def y : Type := Int
def z : x := 1

I was surprised that the last example failed to compile:

▼ 2:14-2:15: error: failed to synthesize instance of type class OfNat x 1 numerals are polymorphic in Lean, but the numeral 1 cannot be used in a context where the expected type is x due to the absence of the instance above

This was fixable by using:

def y : x := (1 : Int)

I had a bit of trouble figuring out that Eq.refl needed an argument, but nicely _ allows inferring the type:

def x : Type := Int
def y : Int := 1
def z : x = Int := Eq.refl _

Of course, I later discovered that there’s a rfl tactic that allows avoiding this boilerplate.

I also ran into some other surprising sharp edges:

def decrement : Nat -> Nat
  | 0 => n
  | 1 + n => n

Doesn’t compile but this does:

def decrement : Nat -> Nat
  | 0 => n
  | n + 1 => n

It’s cool that it’s possible to pattern match on syntax like this, but it’s annoying that it’s a bit inconsistent.

Lambda Calculus Confluence

Basic syntax out of the way, I started implanting the simply typed lambda calculus.

Debrujin indexes:

inductive Term where
  | var : Nat -> Term
  | lam : Term -> Term
  | app : Term -> Term -> Term

Of course, I can’t implement a full interpreter because I can’t solve the halting problem, so I implement single step semantics:

def step_cbn (t : Term) : Maybe Term :=
  match t with
  | Term.lam _ => Maybe.nothing
  | Term.var _ => Maybe.nothing
  | Term.app (Term.lam body) t2 =>
      Maybe.just $ shift_down 0 (subst 0 (shift 1 0 t2) body)
  | Term.app t1 t2 => match step_cbn t1 with
    | Maybe.just t1' => Maybe.just $ Term.app t1' t2
    | Maybe.nothing => match step_cbn t2 with
      | Maybe.nothing => Maybe.nothing
      | Maybe.just t2' => Maybe.just $ Term.app t1 t2'

There’s several different evaluation orders for the simply typed lambda calculus. I recall that Church-Rosser theorem proves that when a term converges, it always converges to the same term regardless of evaluation order.

inductive ConvergesCBN : Term -> Term -> Type where
  | value : step_cbn v = Maybe.nothing -> ConvergesCBN v v
  | step  : step_cbn e = Maybe.just e' -> ConvergesCBN e' v -> ConvergesCBN e v

inductive ConvergesCBV : Term -> Term -> Type where
  | value : step_cbv v = Maybe.nothing -> ConvergesCBV v v
  | step : step_cbv e = Maybe.just e' -> ConvergesCBV e' v -> ConvergesCBV e v

noncomputable def cbv_implies_cbn_convergence :
  ConvergesCBV e v -> ConvergesCBN e v := sorry

I didn’t end up making that much progress. I also tried big step semantics, but that ended up not being much easier, and after Codex and Claude found several holes in my definitions, that made the theorem unprovable as stated, I gave up.

Ecosystem

Lean’s ecosystem still feels fairly immature.

parser libraries: I use megaparsec/attoparsec in Haskell
- fgdorais/lean4-parser: this provides decent parser combinators, but none of the fancier recovery or error handling offered by megaparsec.
C bindings are possible, but you’ll likely need to implement them yourself
effects: monad transformers are the default way of representing effects; usable, but a far cry from Haskell’s wide variety
tooling quite good, lean --server provides top good tooling even in Neovim. I appreciated this compared with using

A meetup

People writing Lean seem to be very dedicated to verifying things for verifications sake. I love that. I think this is the standard for what should be demanded of our libraries and tools.

I’m curious to try diving into metaprogramming, which I hear is pretty good, but that’ll have to wait for another day.

7 Haskell effect systems

Mon, 27 Apr 2026 06:40:00 +0000

An overview of Haskell’s effect systems that I’ve used.

This was written pretty hastily for Inkhaven. I hope to return to this and add more details later.

IO

The simplest “effect system” in Haskell that has been around since the beginning. As an effect system, this just divides functions into pure and impure.

This has a little bit of a special status because Haskell’s main function is declared main :: IO (), meaning that all other effect systems must eventually delegate to IO.

mtl

Monad transformers allow extending a monad with extra capabilities. This allows creating large stacks of monad transformers with a bunch of different effects, e.g. StateT AppState (ExceptT AppError (ReaderT Configuration IO a)).

This quickly gets unwieldy because effects from lower layers need to be lifted through the upper layers.

mtl adds type classes for common kinds of effects, e.g. MonadState, MonadError, MonadReader which can be implemented generically to avoid needing to lift through monad transformers.

As an added benefit this also makes it easier to test functions. A function requiring only MonadState can just as easily be implemented using a pure function.

The worst part about mtl is that declaring new effects requires implementing every relevant type class when declaring a new effect. Conversely, implementing a new type class requires adding an implementation for every relevant monad transformer.

This is called the \(n^2\) instances problem. It’s possible to work around this for the most part with Haskell: the OVERLAPPABLE MonadTrans instance pattern, but it still requires more boilerplate than other effect systems we will see.

ReaderT IO / unliftio

ReaderT IO makes the observation that most custom effects can easily be represented by IO anyways.

Instead of implementing MonadState with StateT it can just as easily be implemented by manipulating an IORef in IO. Why use separate exceptions from ExceptT when IO exceptions can achieve the same purpose?

Because extra parameters are still annoying to pass around, it’s common to still use the ReaderT type to remove boilerplate associated with passing them.

Finally, unliftio makes it easier to express higher order operations like bracket. Because ReaderT isn’t stateful it’s possible to “unlift” it, which makes it possible to represent more generic error handling operations.

It remains a little bit hard to define custom effects and reinterpret them flexibly with this approach. To implement a pure version of an effect, you still often end up stuck with the complexity of monad transformer stacks and the \(n^2\) instances problem.

polysemy

Algebraic effect systems attempt to get rid of the boilerplate involved in defining custom type classes for effects once and for all. They also try to implement fancier algebraic effect patterns.

Based on the weaving pattern introduced by Effect Handler’s in Scope, this library is based on free monads, keeping track of an open union of capabilities.

fused-effects

fused-effects is pretty much like polysemy but uses type classes instead of an open union. This provides a bit more efficiency at runtime trading off for greater boilerplate.

in-other-words

in-other-words is the most creative effect system I’ve seen so far. It provides a really ergonomic interface by providing granular primitive effects that encapsulate higher order effect patterns. User defined effects can be translated into these effects, which makes gets rid of some of the complexity imposed by polysemy and fused-effect’s weaving pattern.

In practice its biggest flaw is its lack of documentation, and the raw complexity of the effects it offers. Some of its effects are extremely general, and reasoning through how they can be instantiated into something useful is really hard.

effectful

Effectful is the application of ReaderT IO / unliftio’s lessons to algebraic effect systems. It implements everything in terms of IO, but wraps it up in a neat interface that makes it easier to work with.

It’s also able to provide a reasonably safe pure interface.

This is currently my favorite effect system for new projects.

500mg Niacin

Sun, 26 Apr 2026 03:38:00 +0000

Experience: Temp full body sunburn

“flushing”

Niacin is a B-vitamin. Sunburn effects lasts 30-60 mins.

You will feel: warm, cozy, itchy.

you’re not having an allergic reaction it’s supposed to be like that

-Handwritten on 500mg Niacin bottle at Lighthaven

I recommend it.

It didn’t feel like a sunburn to me. You know the feeling of a limb falling asleep? It was like that but only 20% as strong, and a full body experience.

Taking it was unexpectedly mindful. I was afraid it would be unpleasant enough to incapacitate me, but to the contrary, it connected me to my bodily sensations.

As I edit this post, I just took another.

One tip: no matter how itchy you get, resist itching.

Disclaimer: This is not medical advice. Read the label and exercise appropriate caution.

Experience Log

19:04 took 500mg capsule of Niacin

19:09 maybe barely starting to feel sore

19:12 feeling a mild warmth in my stomach, right where the esophagus connects, soreness is definitely a symptom and starting to intensify

19:16 a bruise on my shoulder from a few weeks ago is throbbing, very similar sensation to getting a shot

19:18 I’m noticing pain in my lower back that I wasn’t noticing earlier, I’m starting to feel more alert

19:19 I’m going to drink some Rooibos tea

19:20 the pain in my stomach has become a bit sharper, it reminds me a little bit of the feeling of a whole Cheez-It going down my esophagus, but in my whole stomach

19:20 I’m starting to be aware of pain in my upper thigh, just a little bit of tingling

19:21 I’m noticing that my hands are a bit sore while I’m typing

19:21 I’m feeling a tingly itchy sensation first on the back of my neck, and now on the front of my chest

19:22 I also am starting to feel the itchy sensation on the top of my hands

19:22 my foot is throbbing a little bit, kind of like I pulled a muscle

19:22 I’m noticing that my eye muscle is just a bit sandy, and starting to be a bit itchy

19:23 Soreness has extended into my fingertips

19:25 my hands are definitely a bit sore, as though I typed for a long time already

19:26 Rooibos tea again. Drinking doesn’t really feel any different

19:29 I’m feeling quite itchy all over my face, even inside of my nostrils

19:32 I’m starting to notice that my body kind of feels a bit like after constricting blood flow (“fell asleep”), particularly noticing this sensation in my upper left thigh and around my elbows

19:33 Swallowing is starting to be a little bit more noticeable, my throat feeling a bit more bloated

19:33 My left foot is continuing to throb a little bit more

19:34 I’m noticing my tailbone a bit more

19:34 I feel a little bit lighter, and picking up my mug feels a little bit more ethereal

19:35 I’m just starting to notice itchiness on my collarbone, itchiness on my hands feels more intense

19:36 Noticing itchiness inside of my ear for the first time

19:36 My right index finger is pretty itchy

19:37 I finished my Rooibos tea

19:38 My ears tearing up a bit

19:38 I’m pretty itchy under my right arm pit

19:38 My left eye that was previously feeling sandy is now particularly itchy, and starting to water

19:39 My right eye is also watering, it feels like I’ve been using it for a long time

19:39 Inside my left elbow is now particularly itchy

19:40 My muscles are starting to feel a bit sore all over the place

19:41 My right cheek is also feeling pretty tingly now

19:41 I’m noticing tingling around the crown of my head

19:41 My heartbeat is more noticeable

19:42 The top of my head is now on fire with tingling, my hands are feeling very similar

19:42 I can feel my neck muscles when I move them, my neck is starting to tingle quite strongly

19:42 My heartbeat in my neck has fairly high intensity, and the tingling now feels more like fire

19:43 I’m starting to get quite warm, especially on the back of my hands, my ears, and the back of my neck for now

19:46 I feel like my body is humming

19:47 My upper arms are also starting to feel quite warm

19:47 All over itchiness has given way to buzzing/tingling/burning

19:47 My hands are noticeably redder

19:47 I’m feeling some pressure inside of my ear canal like changing altitude

19:48 My calves feel cooler than usual, but it’s possible that it is just because the rest of my body is flushed

19:53 I got up and walked around a bit while trying to convince people to take Niacin, when sitting down I noticed tingles in my upper thigh

19:53 My body is pretty much completely warm now, in a ring around my lungs

19:54 Redness still hasn’t spread too far past my wrists

19:57 I now feel like I need to move around to feel the Niacin

19:57 My eyelids feel a little bit sandy, closing my eyes feels little bit like it does when I have red-eye or my eyes are particularly dry after watching TV for a long time

19:58 Tingling now only really happens when I move around, just a little bit of tingles wherever I move something

19:59 The Niacin is now feeling very normal, maybe just a bit of tingling

20:02 I feel warmth in my stomach in particular again

20:02 Noticing pressure in my ears

20:16 I’m starting to get a bit of chills because my body is changing in temperature

20:19 My skin feels slightly flaky or something when I touch it, I can imagine how itching could quickly intensify the experience and make it much more unpleasant

20:20 My stomach is starting to feel a bit sore, my eyes are watering again

20:22 My eyelids definitely still a bit heavy

20:27 Starting to feel chills all over as the Niacin wears out

20:28 Noticing the tiniest bit of a headache in my right temple

20:32 I still get a little bit light headed and tingly, and a bit stomach achy, starting to feel fairly cool, some amount of cold chills are happening all over my body

20:34 I feel like the symptoms are pretty much all over, just some chills, and a tiny amount of tingles in my belly and tops of my feet + when I move around vigorously

20:44 Symptoms are almost completely gone by now, only a little bit of warmth in my stomach left

20:55 I still feel a little bit light headed as an aftereffect

21:31 My only noticeable symptom at this point is a little bit of a stomach warmth and a little bit of soreness

21:40 I still feel a little light headed especially when I walk around

I don't want your skills

Sat, 25 Apr 2026 04:03:00 +0000

I often notice people advertising their custom skills as a solution to your agentic programming problems. They’ll provide you some genuinely useful advice, then cap it off by offering you skills that operationalizes their advice.

I found the failure modes and tips identified in Software Fundamentals Matter More Than Ever insightful. I never thought about having a glossary of shared vocabulary to make communication with AI agents more effective. AI agents outrunning their headlights by doing way too much autonomously provides metaphor for my common experience of having AI agents do underspecified work. Focusing on building deeper modules with a lot of functionality hiding behind a small interface, is a pattern I’ve been thinking around, but haven’t yet been able to put words to.

But following the insight with skills that will “solve” the problem for you, is the equivalent to giving a tutorial on how to implement nanoGPT and then capping it off by saying: but you can just use https://chatgpt.com¹.

Yes, it does seem helpful to have my AI agent /grill-me — asking detailed questions instead of providing corrections to plans reflecting a fundamental misunderstanding of the problem over and over again. Of course, I’d love to /improve-codebase-architecture modularizing my codebase. But running a skill won’t help you understand how it works.

These skills probably work in simpler codebases. But simpler codebases are also the best environment to understand the principles behind the skills and learn how to build them yourself. And without understanding the principles, you won’t necessarily understand that or how the skill failed in a more complex codebase.

I’ve noticed this pattern before in discussions with other engineers. I explained to another engineer: just giving Claude Sonnet 4.5 our feature flag documentation plus a list of files that needed to modify was enough for it to make the changes fully autonomously. They responded by asking if I could package that up into an /add-feature-flag skill.

I didn’t see the point. The skill would just be 1-2 sentences of text and a list of files that needed to be modified in order to make changes to the feature flags. The skill would encapsulate nothing but the fact that this task was now easy to automate.

My recommendation is to engage with content that offers you skills, but try to learn the principles behind the skills instead of using the skills themselves. Try to prompt your AI agent to solve the problem yourself.

Doing this, I’ve found that after a while, I want to abstract my prompt into my own skill.

I remember reading an article about adding comments to plan documents inline, instead addressing them one by one in Claude Code’s prompt. I liked this technique and after trying it, ended up building produced this skill. Though I’ve provided a link, I recommend not clicking it.

Downloading skills won’t make you a good AI engineer. Understanding why they work and operationalizing the principles behind them will.

Andrey Karpathy does not do this. ↩