I’ve been working on some fairly large vibe-coded apps (like Lion Reader), and my process has converged on:

  1. Write a GitHub issue
  2. (If complicated enough) tell an agent to make a plan and then update the issue
  3. Have another agent read the issue and implement it

As the features get more complicated, I spend more and more time on step (1), and I’m finding that just taking the time to write a detailed enough issue is 90% of the work (and if I have a problem, going back and writing a much more detailed issue usually fixes it). The thing I realized this morning is that writing these issues and working through the plans is very similar to participating in a system design interview: You don’t need to implement anything, but you do need to have a good high-level design, and think through all of the edge cases and tradeoffs.

A sketchnote equating two scenes with a large equals sign: on the left a nervous person presents an architecture diagram at a whiteboard to an interviewer, and on the right the same person relaxes at a laptop while the identical diagram floats out to a friendly robot.

Read more

The United States has a strange (legal) tax loophole where you can double-count capital gains when donating securities (with some restrictions): If you buy a stock, the value goes up, and you’ve held it for at least a year, you can donate it and claim a tax deduction on the current market value instead of the value of what you paid for it (the cost basis), and you don’t pay taxes on the gains.

Sketchnote: a stock bought for $15k rises to $30k in value, then splits into two coins — one dropped into a charity donation box labeled "deduct $30k", the other landing on a crossed-out IRS form labeled "skip the gains tax".

Read more

I’m working on an experiment comparing the internal representations of two architectures when solving a sequential algorithm, but training models to use a sequential algorithm is surprisingly hard. The optimization landscape makes it easier for models to learn parallel algorithms or memorize lookup tables, so I needed to make some specific architectural and training decisions to get models to actually learn the sequential algorithm. Even with all of these tricks, the results are seed-dependent and I needed to inspect the resulting models to prove that they did or didn’t learn the expected algorithm.

In this post, I’ll document what did and didn’t work, and the techniques I used to prove whether or not the model learned a sequential algorithm.

A hand-drawn grid with layers L0 to L6 on the vertical axis and steps 1 to 6 on the horizontal axis. Exactly one teal cell is filled in per column, and the filled cells climb diagonally from bottom-left to top-right like a staircase. A cartoon robot climbs the staircase and a dashed arrow traces up it, labeled "one step per layer".

Read more

When you’re subject to capital gains taxation, the government shares in some of the upside, but when you have capital losses, the government shares in the downside too. Because of this, the actual risk (and reward) of any given portfolio is lower than it seems. To counteract this, you should consider shifting your allocation toward riskier assets.

Sketchnote titled "The Government Is Your Silent Partner": three panels showing (1) on gains, they take ~20%; (2) on losses, they give some back; (3) so your real risk is only the 80% you bear.

Read more