The agentic workflow is something I’m calling “local, parallel, and autonomous”. It’s a dive deep into making a whole codebase from scratch, completely hands-off.

The Core Attributes

The main pillars for this workflow are straightforward:

• Local: All the git worktrees run locally on my machine, avoiding the complications of remote execution.
• Parallel: It’s built to scale so multiple agents can work on different issues across multiple worktrees at the same time.
• Autonomous: The agents complete issues from start to finish without human intervention.

Choosing the Right Projects

Let’s be clear: as of March 2026, there are a lot of risks with this approach. I wouldn’t confidently build and deploy a production SaaS web application this way because the necessary guardrails for safety and privacy requirements just aren’t there yet.

Because of that, I choose self-contained, smaller projects. I’ve built a few codebases this way, including:

• Small VS Code extensions (one to synchronize my dotfiles, another to add missing file operations).
• A self-contained GitHub page that converts LaTeX to Markdown and plaintext.
• Lelouch, the workload orchestrator I use for this very process.

For more complex, large-scale systems, I still rely heavily on a manual cycle where the AI generates code and I heavily review it.

Bootstrapping: Setting the Guardrails

To get things started, I wrote a repository called agentic-bootstrap to provide the scaffolding. Inside its templates/ directory, I keep generic rules that help agents stay on the rails.

The bootstrap relies on a few key components:

• AGENTS.md: This file acts as the playbook. It tells agents to study the README first, ensures CI passes, enforces linting rules, and mandates that documentation is always updated.
• specs/: This directory holds design specifications. Splitting the design up limits the context an agent has to load to accomplish a particular task, separating the “designer” agent from the “executor” agent.
• Example Files: For the Heaptrack UI, I included a sample .zst file in the repo so the agent actually knows how to read the format it’s supposed to parse.

Writing Specs: The “Grill” Approach

When it’s time to write the overall design, you can write it yourself, but I used an approach called “grilling” to illustrate another, more agentic way to bootstrap.

I tell the agent: “Interview me about the purpose of this project”. It asks me questions about architecture and UI, and I respond with my requirements—for example, that the app should be a purely client-side React app, include dark mode, and support drag-and-drop.

The agent then writes out the design documents in the specs/ directory. I usually do a quick offline review; for instance, the agent once hallucinated some weird typography requirements asking for “Apple’s clear glass” style, which I promptly deleted.

Managing the Queue with Beads

For the issue database, I use a tool called Beads, created by Steve Yegge. It acts as a local database for issues, supports being reused across multiple work trees, and is highly agent-friendly with support for --json flags.

You simply initialize it with bd init --stealth. From there, you can manage the queue:

• bd create to make new issues.
• bd update {id} --status=open or --status=closed to manage state.
• bd delete {id} to remove them.

I like to use a “thinking” model for a seeder prompt to write highly detailed initial issues, and I use the Beads VS Code extension to visually track what the agents are working on.

Orchestration with Lelouch

To orchestrate the workers, I wrote Lelouch. It’s effectively a way to run an agent, one per github worktree, pulling issues out of the Beads database.

To initialize it just run lelouch init per worktree. It monitors your repositories, pulling open tasks from the Beads database by priority and dispatching them.

I typically run Lelouch with the Gemini Flash model via CLI because it has a more forgiving usage limit. I also add a pre-prompt like “run tests, commit, and push” to make sure it follows through.

When I run lelouch run -v, the loop begins. It moves issues to “in progress” and logs the agent’s responses directly into the working notes, so I can see exactly what it’s up to. It’s incredibly satisfying to just watch the issues update in the VS Code extension while the agents hum away.

Handling Bugs and Gaps

The process isn’t perfect. During my Heaptrack build, the agent created a gaps.md file but failed to actually implement the missing features. I had to manually prompt it: “There are gaps in gaps.md that are not yet implemented. Please create BD issues for them.”.

When I tested the UI, I found that the flame graph had sizing issues and the .zst file wasn’t loading properly.

Fixing this is a matter of adding issues to the command line via bd q "fix the bug with the zst file not outputting the flame graph". Lelouch immediately picks it up in the background.

Takeaways for 2026

I’ve done this with four or five projects now, and having a central issue database with parallel worker agents is a scalable model.

I know that there’s been existing examples online of people who have done everything from write compilers over to full web browsers, and games with varying success. Despite that, I’m still skeptical and looking for ways to get it to be a consistent, high quality enough generator that it can be used for more production code. To get there, I think it’ll take more guardrails, especially security-related ones. Some projects are already using agents with a security persona to try to get there.

But all technology has to start somewhere, and this workflow serves as an interesting baseline for my process I intend to grow.

Recently I read about Steve Yegge’s post about GasTown, an ecosystem of agent orchestration to go get monster-sized projects done.

I was a bit slow on the uptake when it came to AI: a lot of code last year was hand-written when many had already started letting agents do most of it. My thought was, at the time, the models themselves were often unable to produce a working feature. Let alone produce good code.

But only a year later, with models like Claude Opus 4.6 and Gemini 3.1 pro, these agents are generating code extremely quickly. And the code is actually… decent. It’s not mind-blowing - the agent still makes multiple stylistic mistakes, despite my prompt telling it not to:

• It does not adopt functional programming methodologies, freely mixing IO with business logic.
• It repeats itself constantly.
• It often re-writes things it can use a library for.

But it’s good enough where I can get into a productive loop.

My workflow today

My workflow looks like:

1. Write up a design or prompt (I usually like to document my actual written prose somewhere, usually a DESIGN.md).
2. Ask Cursor / Claude / Gemini to implement it.
3. Review the code, ask it to fix things. Back to 1 if needed.
4. Validate the feature e2e. Back to 1 if needed.
5. Commit and push.

I’d argue this is very hands-on. But even with this level of micro-managing, I get a ton of changes done in a short period. Over 1.5 hours on a random Saturday, I got through 7 feature requests in aep-e2e-validator, and I felt good about the code and the result of those. Probably 3-4x what I could with a coding-first approach, and with probably one half of the mental load.

Oh, and I also created a code extension to fill in some missing gaps I had in openvsx (https://github.com/toumorokoshi/code-fileclrk). And a couple bugs in other repositories. So I guess that’s more like 10 contributions in a 1.5 hour period, and a 5x increase?

Regardless the multiplier at this point is astounding. As Steve said in his blog post, the bottleneck here really is no longer the code.

My workflow in the future

I thought the above was great, but then I read GasTown. To be clear, I am a still a pessimist on AI, so I don’t want to say I’ve drunk the Kool-aid just yet. But the extremely detailed post helped me really understand what an 100x future could look like. It’s basically layers of abstractions, but with AI agents filling almost every single piece of the puzzle:

• agents are writing code.
• agents are reviewing PRs.
• agents are helping summarize the changes and writing them out to a record of what decisions were made.
• you talk to an agent to help dispatch these tasks to other agents.

And so on - multiple role-based agents, that fill whatever gap you’ve encountered with the other agents you’ve already deployed. Assuming the agent is good enough, or you’ve anchored the manual review to the point of no return (e.g. before performing a financial transaction, or perhaps cutting a release), you could delegate the next level of review over and over again.

And intuitively - this kind of makes a wacky kind of sense, where you are abstracting yourself to the point where you are focusing on the problem where human judgement is truly needed. In the past, for someone to get something accomplished with software, you had to work on every single piece by hand (perhaps except the hardware you run on). But now, if there’s a task you don’t find particularly appealing, and as long as you’re willing to do some manual review, you can definitely delegate that to an agent!

The caveat: you need the domain knowledge to succeed

Some might read the above and believe that this means that an individual does not need the same skills that the agent does. For example, a non-technical person can write software. I don’t really believe that’s the case, at least not 100%.

For one, it’s important to know that there are just some concerns that are so mission-critical that you cannot reasonably accomplish that without some sort of expertise or awareness. Those are:

• Proper resource management, quotas, and monitoring so you don’t get a giant check that backrupts you.
• Security. If your service is compromised, the damage is irreperable.

But there’s a huge swath of things that you don’t really have to understand too deeply at the beginning. And as long as you have the skills and time to dive in, AI could take the first swag at it:

• command-line interfaces.
• applications that run locally.
• any codebases that have significant guardrails (linting / testing / etc).

Final Thoughts

So what is the bottleneck now?

It feels like the bottleneck now is the human’s ability to reason about a problem and figure out a good solution. I suppose one can argue that human reasoning was always the bottleneck, but I think the abstraction is at a higher level now.

Oh, and money / energy. You can produce as much as you have money to pay for an agent to generate for you. That or your human ability to think about these problems, which limits you first.

Human interaction is still needed

In this fever dream of AI, there are no humans. But to make real change happen in an organization, you still need to talk to people, and that’s the real challenge.

Pretty much everything that has real impact, to some extent, requires thoughtful interaction with others:

• Getting buy-in on the idea.
• Getting others to use it (sharing demos, recordings, talking to people in 1-1s and through slack).
• Getting approvals to merge or ship the code.
• Getting the team that owns the product to accept your idea and put it on their roadmap (or accept your code).

So although some coding is trivial now, I don’t believe that the bulk of the my work, for example, is removed. Communication and interaction with individuals is still key.

Agents give us the freedom to dive into the problem we want to

Perhaps there is a world where someone chooses to completely ignore code or a particular engineering problem algother. But I don’t really see this as my motivation.

I think agents provide us the freedom to work on the problems we want to, or perhaps minimize the time we spend on the problems we don’t want to work on. We have a fairly autonomous coder / problem solver than can get things mostly right, and we can trust if we need to.

But if we want to, we can dive right in! And there’s reasons to do so: the code may have gotten too messy, the abstractions are not easily understood, or the code is not performant.

And if you want to assert that level of control and code something yourself, you can! So again, in some ways it’s refreshing in that you can spend more of your time on the problems you care about, not just the rote ones that need to be done.

When and how will we get to this glorious future?

So when can we get to this world where agents completely autonomously write their own code and produce real, working products?

I think for some software engineers, they’re basically there today. GasTown seems like it’s run fairly automated with agents working on it all the time. I don’t think throwing agents at compilers and browsers has produced a working product either.

For me personally, I don’t know if I have a project that really is accelerated by 100 autonomous agents all writing code. But I’d like to start climbing this maturity ladder to see if I can squeeze out a little bit more of that time to think about the problems I’m really interested in diving into.

Summary

This post outlines an experiment I ran to try to better understand the unique data inputs I’m using for model training. This is a modification of DVGS - “Data Valuation via Gradient Similarity”, that I’m calling DUGS (data uniquess via gradient simlarity).

Algorithm high level

The high level idea is:

1. Grab the following: a. An already trained model b. A random sampling of the data you would like to evalute of size X
2. Initialize a map of {data_point_id, uniquess_dimension} to store differing data points.
3. Run a training pass on each datapoint. Calculate the gradient up to a layer Z.
4. Reduce the dimensionality of that vector via a random matrix {gradient_size, uniqueness_dimension} to reduce the cost of calculating gradient similarity. (Johnson-Lindenstrauss projections)
5. Use cosine similarity to compare it to existing vectors in the list
   1. if the similarity is less than some threshold (0.3 by default) from any of the previous data points, add the new data point to the list.

Tunable parameters

Data Set Size

The size of the data set you are running the evaluation on will affect the runtime of the algorithm linearly.

Uniqueness dimension via Johnson-lindestrauss lemma error

The smaller the dimension size you can reduce to, the more efficient the calculation is.

The Johnson-Lindenstrauss Lemma states that preserving the vector dimensionality within an error bound e for a dataset size N is calculated as:

k > (8 * ln(N) / e^2)

Although we are only seeking a limited number of datasets, making this match the target full dataset size ensures that there is sufficient dimensionality to understand the nuances between the dataset. The main tunable parameter is the margin of error introduced by the reduction of matrix for comparison.

For example, for 10,000 images, and a desired error of 0.001, you would have to have a base 2 dimension of roughly 8 * ln(10000) / (0.001^2)) = 73682722, or somewhere between 2^26 ~ 2^27 (rounding to some base 2 size matrix is preferred to align with scheduling on processors which primarily have cache sizes, multithreaded processor / code SM counts that align to some multiple of 2).

Number of layers to backpropagate

This one is a model-specific choice: the more layers that backpropagation is run, the runtime complexity will multiplied by the cost to compute the backpropagation of that layer.

As a rule of thumb, I think you want to only go back to the number of a relatively low number of layers: there is an intuition that the later layers of a model are the ones more correlated to fine-tuned behavior for the specific task. This is probably the behavior that one is most interested in, such as wehn trying to find more datapoints of similar, but underrepresented data, to increase the distribution thereof.

Results

I tried this out in my sandbox against my toy model based on AlexNet, which uses the Imagenette dataset. Looking at the results visually, it looks like it was able to differentiate and find examples of each of the 10 categories:

Future Experiments to try

• focus on the gradient of a specific layer (e.g. the embeddings)
• use dimensionality reduction via Johnson-Lindenstrauss projections
• can we use some form of k means clustering to help group the data points?
  • this would be helpful to see how many “categories” of data there are.

My Framework 13 laptop has an issue where the battery drains very quickly, even when sleeping.

This seems to be a known issue with Framework laptops. Since I often just use my work computer during the weekdays, the laptop is dead before I can use it again.

Reviewing sleep states available

In Linux, there are specific levels of sleep states that can be used:

• freeze (S0ix)
• standby (S1): rarely used in modern systems.
• mem (S3): hardware is powered off except ram.
• disk (S4): hibernate. system state is moved to disk.

Checking power states available

First I checked what was available with:

cat /sys/power/state
# freeze mem

So freeze and mem are available.

Configuring hibernate with LUKS

I like to use LUKS (Linux Unified Key Setup) to encrypt my drives. To do so with hibernate, the following workflow is required:

1. use the bootloader to loader the initramfs
2. have the initramfs decrypt the LVM volume that contains the main partition as well as swap.
3. the initramfs detects that the swap partition is available and restores the system state from it, if a hibernate image is found.

Configuring the partitions

The final partition structure will look something like:

• /dev/nvme0n1p1 (EFI / bootloader)
• /dev/nvme0n1p2 Linux filesystem partition: an unencrypted boot partition that contains the OS needed to perform the decryption of the encrypted drive.
• /dev/nvme0n1p3 Linux filesystem partition: the encrypted disk partition.
  • /dev/mapper/dm-crypt-0
    • /dev/mapper/ubuntu–vg-ubuntu–lv: the actual OS.
    • /dev/mapper/swap: the swap space that the partition will hibernate to.

Steps

NOTE: these were with my install of ubuntu 25.10. YMMV.

Resize the partition and make a swap partition

1. use a live USB so I can modify the partition
2. open the luks partition: sudo cryptsetup open ${partition} ${lvm-volume-name}
3. reduce the size: sudo lvreduce -r -L -128G /dev/mapper/${root-lvm-partition}
4. create the volume: sudo lvcreate -L 128G -n swap ${lvm-volume-name}
5. format as swap: sudo mkswap /dev/mapper/${swap-lvm-partition}

Make the partition swap

This ensures the swap partition is available on boot to suspend to.

When back into the OS:

1. sudo swapon /dev/mapper/${swap-partition-name}
2. Update /etc/fstab to mount the swap on boot:

/dev/mapper/{swap-partition-name} none swap sw 0 0

set the swap partition as a hibernate partition

This tells the kernel where to look for the hibernate image when resuming.

1. modify GRUB_CMDLINE_LINUX_DEFAULT in /etc/grub/config with:

resume=/dev/mapper/{swap-partition-name}

1. run sudo update-grub

enable hibernate in the linux kernel image

This is required for the initramfs to know how to restore from the hibernate image.

1. create file /etc/initramfs-tools/conf.d/resume with:

RESUME=/dev/mapper/{swap-partition-name}

1. run sudo update-initramfs -u -k all

disable secure boot

The last step is to disable secure boot in the BIOS.

Theoretically there is a way to sign the hibernated image with a TPM (trusted partner module) or a MOK (machine-only-key), but I didn’t want to have to re-encrypt my volume.

Conclusion

Success! After the above, I can now hibernate my laptop.

Even with my 64GB of RAM, the hibernate / restore has been pretty quick so far: roughly 20 seconds at most to come back up from a full hibernate. Good solution for laptops I use once in 24 hours.

see /diet/2022 for an older version of this article.

Short checklist

• Vegan diet
• Drink caffeinated drinks (e.g. coffee) to suppress appetite, and to help combat memory loss.
• Sodas are a great way to suppress appetite.
• Target 1.6g protein / kg body weight day.
• Target 45g fiber / day.
• Try to get as close to zero for saturated fat intake.
• Target 1400kcal for cutting, 1800kcal for bulking.
  • when bulking, do a slow bulk to build muscle.
• targetting low carb diet (50 carbs / day).
• Moderate sodium intake
• Try to hit 100% RDA on potassium (this is very, very hard): this helps counteract bloating caused by sodium.

Example diets

Major Ideas

Mostly vegan (plant-based diet)

People who eat a plant-based diet live 7 years longer.

It’s hard for me to go completely vegan (I like my seafood and dairy), so I try to go for vegan meals most of the week at home. When I eat out I eat vegetarian or seafood.

From what I read in Blue Zones (above), eating meat once a week still helps you get a lot of the longevity benefits.

Those who have plant-based high protein diets also tend to have better kidney health than those who dairy / meat based high protein diets.

High-protein

I eat 1.6 grams of protein per 1KG of body weight a day at minimum. Studies have shown that this is the amount that has shown to maximize muscular hypertrophy. I strive to maximize muscle mass ultimately for increasing my healthspan.

With a vegan diet, that number likely should be higher: vegan proteins are not always complete, and may not be in an easily digestable form unlike meat.

However, I do strive for foods that have a diaas score close to 1 or greater:

• soy protein isolate, soybeans, soymilk, tofu.
• pea protein.
• beans (kidney, fava).

Targetting Caloric Restriction

I’m currently in the middle of trying to lose weight: my last Dexa scan in 2022/10 put me at 21% body fat, which is much higher than I’m hoping. My current target is 15% body fat, which means I have to lose 12 lbs of body weight.

To that end, I’m looking at some minor caloric restriction: at 1700 kcal / day, and assuming I can build up a daily caloric expendature of 2100 kcal, that would be me at 3500 / (2100 - 1700) ~ 8.75 days to lose a pound of weight. And ideally I could my weight in 108 days (~4 months).

I’m mixing that with lifting weights to try to guarantee muscle hypertrophy.

In reality my caloric intake is often higher due to limited self-control, but I’m working on that.

Other Tips

Sucralose may cause NAFLD

When I started eating four servings of Huel protein powder a day (to try to up my protein intake, those 80 grams help) along with drinking a sugar-free sweet coffee daily, I found that my ALT and AST numbers have grown significantly (11->16 and 17->25, respectively over 10 months).

I’m not sure the precise cause, by after doing some research I found some research in mice that shows sucralose and stevia (and regular sugar) consumption increasing ALT and AST.

Correlation is not causation, but I’m currently (2023/04) trying to lower my Sucralose consumption significantly to see if my numbers change at all.

Only Allulose and Stevia for non-nutritive sweeteners

Several non-nutritive sweeteners have downsides:

• Aspartame may cause an insulin response.
• Erithrytol may cause blood clotting, and impact the blood/brain barrier.
• Sucralose may cause NAFLD.

Which leaves a limited set of non-nutritive sweeteners to choose from:

• Allulose
• Stevia

Specific Food Recommendations

To hit a 50 carb target with 1400 kcal, you need to target foods that provide roughly 1 carb per 26 kcal or less.

Also, unlike most low carb diets, I prefer to stay low in saturated fat as well. It’s a hard balance but I try to make sure these foods have relatively low saturated fat.

For my specific dietary preferences, my recommendations are:

Nespresso

I like to drink Nespresso every morning. I generally may make a mezzo (half americano, half soy latte) with the following:

• Mezzo with Tropical Coconut Flavor + 180ml soy milk.
• Straight: Peppermint Pinwheel.
• Bianco Doppio with 120ml milk.
• 2x Altissio with 180ml milk (I like this because they offer a decaf option).

Sometimes I replace the soy with a larger volume of macadamia milk (fewer calories).

Good Foods

• Pistachio: relatively lower carbs, low saturated fat, high potassium.

  • high phosphorous so try to eat it in moderation.

In my spare time, I’m learning Farsi. I’ll use this as a kitchen sink for my notes on the language.

Peyda Konam

In farsi, there are phrases such as

ادامه پیدل کنم

The peyda konam (found X) is used in a situation where a direct action is not taken to make the object achieve that state.

For example, you could say “if the revolution continues…” - but this does not refer to any specific object ensuring the revolution does continue.

This is where “peyda konam” comes in. Since it’s nebulous whether it will actually happen, it’s about it finding itself in a situation when it does occur vs actively being done.

Mitoonestan

The word mitoonestan (می‌توانستم) is the past continuous/imperfect form of the verb tavānestan (توانستن), which means “to be able to.”

Mitoonestan is interesting, because it is a model / auxiliary verb. Model / auxiliary verbs require a main verb to clarify what is possible / what is desired / etc.

So applying the past tense to these case is complicated, and the way that it’s done in farsi is to conjugate the modal verb, not the main verb.

e.g. I couldn’t do it is نمتستن کنم.

The word “az” is used sometimes where it’s not in english

Sometimes you might hear an Iranian use phrases like “thanks from” when speaking English. This is be cause in Persian, the word for from, “از”, is used as a preposition where it is not in English.

For example, “thanks for” is actually “thankful from” (تشکر از).

Always use “keh”, even for “who”

Unlike English, where we use “who” for people and “what” for things, Farsi uses “keh” for both.

For example, “who is there?” is “کی اونجاست؟” (key unjāst?) - but “what is there?” is “چی اونجاست؟” (chi unjāst?).

Use “chand ta” for unknown quantities

When you’re asking about a quantity of something, and you don’t know the exact number, use “chand ta” (چند تا).

For example, “how many apples are there?” is “چند تا سیب اونجاست؟” (chand ta sib unjāst?).

This is in contrast to “chand hafte ha” (چند هفته ها) which is used when you’re saying a quantity (plural is attached to the object).

I’ve been thinking a lot about how to do well in system design interviews recently. Aside from the obvious utility in getting an offer as a software engineer, I think there is some happy union where being good at a system design interview also can provide a good rubric at doing off-the-cuff system design.

Here’s my notes on my ideal workflow, that I plan on iterating on as time allows.

1. gather requirements
2. API design (maybe you could do this during “gather requirements” as you figure out usage).
3. block diagram
4. data storage

1: gather requirements

I think requirements have a minimum checklist: have you thought about every intrinsic attribute that could affect your system?

The common ones, in my opinion, are:

• usage requirements (start with this first)
• seasonality in usage patterns (e.g. are certain days / months heavier than others)
• read / write load (or read-heavy / write-heavy)
• latency requirements
• geolocation
• uptime requirements
• scale

Then anything more domain-specific to the problem at hand.

napkin math around requirements

“napkin math”, where you try to do ballpark estimates of the numerical requirements or properties of your system, are a must for system design, and in interviews I found myself getting into doing really complex numerical conversions that I honestly couldn’t do in my head. A lot of it had to do with the base 2 calculations vs the base 10 calculations and interchanging them.

To help with this, I have the following framework:

1. Calculate the data storage in bytes (base 2 calculation)
2. Do estimates in multiples of ten if possible (e.g. 500k users). Write that out as powers of 10 (e.g. 5*10^6)
3. Estimate requests per second by estimating the total activity per day, divide by 10^5, then multiple by 1.1.

The third one requires a bit more explanation. Basically:

• There are 86,400 seconds in a day.
• 100,000 / 86,400 ~ 1.15. Which we can further ballbark to 1.1 or 1.2.

This, combined with using multiples of ten for users, makes the math really really easy. 1.1 is very easy to mentally perform as well.

Figure out data storage

Question: which two of the CAP theorem are most critical for the storage of the data?

Every systems design problem has some sort of data that you need to store. On that note, I’ve seen a couple different flavors of “data storage” discussions:

1. Thinking about the design patterns to use based on the properties of your business problem.
2. Discussing real-life databases or categories that you might use (e.g. SQL vs document database).

To hedge your bets, I think you should start with 1 where you think about the data structures, and know how to map them to the database that implement.

A common data structure is to:

1. have a dataset split into multiple “shards”
2. replicate each shard into replica sets (each replica set could have a single master via paxos quorum)
3. have the metadata of each replica server started in a config server.
4. have the config server heartbeat into replicas to do coordination (e.g. disenroll)
5. the master has a write-ahead-log to store the transactions, ensure ordering. Add a checksum to ensure the operation completes. Otherwise query master for correct row data and re-verify.
6. replicas replicate the WAL and perform subsqeuent writes.

graph TD
CS[Config Server] --> RS1[Replica Set 1]
CS --> RS2[Replica Set 2]
CS --> RS3[Replica Set 3]
subgraph "Shard 1"
RS1 --> M1[Master]
RS1 --> S1A[Replica]
RS1 --> S1B[Replica]
end
subgraph "Shard 2"
RS2 --> M2[Master]
RS2 --> S2A[Replica]
RS2 --> S2B[Replica]
end
subgraph "Shard 3"
RS3 --> M3[Master]
RS3 --> S3A[Replica]
RS3 --> S3B[Replica]
end
%% Heartbeat connections
CS -.->|Heartbeat| M1
CS -.->|Heartbeat| M2
CS -.->|Heartbeat| M3
CS -.->|Heartbeat| S1A
CS -.->|Heartbeat| S1B
CS -.->|Heartbeat| S2A
CS -.->|Heartbeat| S2B
CS -.->|Heartbeat| S3A
CS -.->|Heartbeat| S3B

Organizing and communicating in a design interview

• have three different text sections: this will help communicate to the interviewer what assumptions you have made.
• requirements/
• API?
• user journey?

Deeper notes

Design patterns per use case

Design Patterns when considering data storage

Choosing the partitioning key for data locality.

Similar to Google bigtable, one could choose the partition key for rows by some structure that ensures that for most queries, the query only has to send a request subset of nodes, rather than all of them. This:

• reduces the query load on all nodes.
• also reduces the latency of the request, since fewer nodes have to respond.

Paxos

The Paxos algorithm can be used to achieve consensus across multiple separate hosts.

The Google Chubby lock server can handle ~20 req / s of content updates, with a significant number of reads and KeepAlives.

write-ahead log

A write-ahead log can be used to ensure durability in the operations that are performed. A transaction can be acknowledged after it’s committed into a write-ahead log.

Expontial backoff

Read locks and write locks

Read locks (aka shared locks) are a common database pattern which allows multiple readers on a row of data, preventing mutation. It prevents subsequent writes until all readers have released a lock.

Write locks are an exclusive lock on the row, blocking both reads and writes.

Here are some snippets of vs code debug configuration to easily copy-paste as needed.

Go

Running a command line tool

I’ve used this for when I’m trying to debug aepcli

       {
          "name": "Debug Command Line App",
            "type": "go",
            "request": "launch",
            "mode": "auto",
            // or path to command line
            "program": "${workspaceFolder}/cmd/aepcli",
           "args": [
               "http://localhost:8000/openapi.json"
            ]
        }

Although, like many food pyramids before it, there is a very strong lobbyist influence on this guidance (The New York Times covers it well), my thoughts are primarily on the guidance itself, as a health-conscious person who has done some reading on nutrition from folks like Dr. Peter Attia.

Summary

My thoughts on the guidance is overall positive. But the changes I would make are:

• Limit saturated fat as much as possible, similar to added sugars. Eating more saturated fat directly correlated to a higher increase in apob and cardiovascular disease.
• Eliminate the conversation around whole foods vs processed foods. Acknowledge that most processed foods are nutritionally unhealthy, but focus on the nutritional content and not the processed nature.
• Continue to focus on a plant-based diet. This is primarily because the amount of water and resources required to produce plant-based foods is significantly lower than the resources required for meat or most dairy. But meat is generally high in saturated fat so it’s best to avoid that anyway.
• Positive changes: increased protein and fiber recommendations, reduction of high-carb foods in the pyramid.

The details

Pros

Increased protein intake

Generally, higher protein intake enables the body to build more muscle, although resistance training is much more important. This is especially critical in the later years where it’s incredibly hard to build muscles and strength.

Reduced bread / simple carb intake

It’s surprising that the original recommendations in the food pyramid were so heavy on carbs. Although ensuring you have enough energy throughout the day is a good thing, a carb-heavy diet can result in a lot of insulin to digest the glucose that is produced as a result, and can contribute to diabetes.

There’s definitely healthier carbs in whole grains, but it is better to balance more protein or fats as well.

Eliminating bias around fats

Unsaturated fats help improve satiety, and also reduce the number of carbs required to reach the daily caloric recommendation. I still think low-fat foods have their place, but as long as the fat is unsaturated, it is generally less causal to high ldl / apob, and is a good macronutrient to include in the mix.

Mixed

Well-intentioned, but incorrect, focus against processed foods.

The document focuses heavily on the concept of “real” foods, advocating against highly processed food.

If you’re not willing to think about the nutritional content of food a bit more deeply, then I think it’s general it’s good guidance: most highly processed foods have extremely pool nutritional content, with high saturated fat, carbs, and low protein.

However, this pairing ends up being a confounder: there just are not very many healthy but higly processed foods, and so most studies on highly processed food end up showing results very similar to studies on foods high in saturated fat, carbs, and low protein.

Although it’s not a study, an anecdotal counterexample is huel: definitely highly processed if you look at the ingredient list (dozens on ingredients, micronutrient blends), but many who run labs on the huel subreddit after multiple months exclusively on huel report lost fat, maintain muscles, and generally better labs such as blood pressure (1, 2).

Another anecdotal example, is myself: my diet is primarily processed foods: I eat keto bread, protein powders, artificial sweeteners, huel, and sometimes slimfast (although when I eat “real food” it’s generally roasted whole vegetables).

However, my labs for the past 2-3 years on this diet have only improved over time:

• triclycerides are 50.
• ldlc is 80 or lower.
• body fat is the lowest it’s ever been.
• blood pressure is consistently below 120/80: ten years ago I was generally right on the borderline.

Which indicates to me the concerns are largely about the overall nutritional content, not about the processed nature of the food.

Against, it’s generally good guidance, but is pointing at the wrong cause.

Cons

Disregarding saturated fat

The guidance effectively eliminates any guidance around saturated fat. Multiple studies at this point have proven the correlation between high saturated fat intake and apob (the lipoprotein that primarily gets caught in the subendothelial space of the arterial wall, contributing to ASCVD), so to ignore it’s guidance in my opinion, is mistaken.

This is probably the guidance that I would be the most concerned about. It’s probably also not a coincidence that, since many meats and dairy tend to be much higher in saturated fat content than plant-based options, ignoring saturated fat tends to benefit the meat industry the most.

The only guidance is the existing one which suggests limiting saturated fat intake to 10% of calories or less a day: in a 2000 kcal diet, that’s 200 calories, or roughly 22 grams. It’s less reinforced in the new narrative.

I’d replace this guidance with limiting saturated fat to near-zero as much as possible, similar to added sugars.

Eating more meat over a plant-based diet

This particular con is less about the nutritional content: farming meat requires significantly more water and land than growing plants. I don’t think it’s really tenable to continue to increase the usage per capita for food, especially as the population keeps growing.

Conclusions

I left my summary at the beginning, but my parting thoughts: It’s unfortunate that science, like anything human, has to be so strongly biased. And I see parts of this new guidance that has significant cons.

But that said, the old guidance was not perfect either. I hope the next version (no doubt swiftly replaced by the next administration run by a Democrat) corrects some of the issues I’ve raised above, without regressing on some of the improvements.

I finally got a Framework 13 laptop! This is something I’ve wanted for several years, ever since they started shipping their laptops in 2021.

A quick intro to framework

Framework focuses on repairable, but also modular, devices. They have produced laptops in the 12,13, and 16 inch form factor, as well as a desktop. Some of the features that are specific to Framework devices include:

“swappable I/O”: effectively there are slots of USB-C ports that have a square notch in them, paired with adapters to various common ports like USB-A, DisplayPort, or HDMI. The result is the user-facing ports are effectively changeable, to some extent on the fly: it’s hard to change the port in, say, a second, but if you had 20-30 seconds I think you could change them out.

Repairable / interchangeable parts: there is a whole Framework store with replacement parts for everything from batteries to webcams to keyboards. You can change things like the bezel color around your monitor, or for the desktop they have square chicklets that you can replace with your own flair.

What motivated me

So why the wait? Well, at the time I had a working laptop from 2018 that was working perfectly okay. It still even works okay (battery has only degraded to maybe 80% or so at most).

So in 2025, there’s a couple things that have changed for me:

• The availablility of RISC-V and ARM boards especially.
• The AI HX 370 processor, released this year.

Impressions and thoughts

Overall, I’m very impressed and happy with my 13. I bought the “DIY” version, which require some self-installation of the RAM, hard drive, but I preferred that as it gave me time to quickly get a more visceral sense of the device.

It’s also my first laptop with the 3:2 display, which runs taller than the ratios typically seen in laptops these days. I do feel like the extra vertical real estate is noticeable, and helps a bit with coding or text-based tasks.

I’m also happy with the performance: the device feels extremely snappy with Ubuntu 25.10 and the standard Gnome display manager. Videos and tabs load quickly. Aside from games there is no percievable latency as far as processing is concerned.

Of course, my frames of reference are an M2 MacBook Pro from 2022, and an HP Spectre X360 from 2018, but compared to both of these my laptop feels much smoother.

Battery life also seems to be holding quite well - I charge pretty aggresively regardless, but even for heavy workloads like gaming with 100% GPU utilization I’m looking at 1-2 hours. If it’s more lightweight work than that I have not yet thought about battery at all, but I’ll probably do some more emperical benchmarks soon. powertop reports a draw of 7 watts or so at this time, so I’m guessing for light work I can get about 7 or 8 hours.

The build of the laptop is also very nice - The aluminum feels very similar to a Macbook, but the device feels much lighter than the M2 PRO. This feels like a “premium” laptop to me.

Availability for RISC-V and ARM boards

The amazing thing about Framework devices are not just repairability - it’s the modularity as well.

The 13 form factor in particular has been so successful that other vendors have started producing compatible boards:

• DeepComputing’s RISC-V board
• MetaComputing’s ARM-based board.

Improving support of alternative processors seems like an amazing hobby project. Especially ARM with the recent announcement of it’s integration of FEX-based emulation of X86 to play steam games on ARM devices.

The AI 9 HX 370

I’ve been angling for the Framework 16 in particular because of the higher TDP, ensuring that I can use the maximum potential of any hardware I have for the device. This was also to ensure I could upgrade the GPU as more resource-intensive games are released.

However, the AI HX 390 seems to have a pretty amazing iGPU, with the Radeon 890m. In my benchmarks I’m getting good enough framerates to accept it on the off change I’m gaming on the go. Note that these are using single-channel memory so the GPU can likely perform much, much better:

• 30-40 FPS with Cyberpunk 2077.
• 30 FPS with Balder’s Gate 3.
• 30 FPS with Expedition 33 (with some really low resolution settings).

Some more lightweight games like Dispatch run at 60fps, just as good as my desktop.

For AI

I’ve recently started dabling with ML model architecture and training. My reproduction of the AlexNet paper on the Imagenette dataset trains 60 epochs in about 3-4 hours. This isn’t nearly as fast as the 30 minutes on the L4 GPUs available through Google Cloud that I normally test against, but it’s still a decent showing, especially limited at the 30w TDP.

Mistake: buying single-channel memory

Honestly I wasn’t thinking straight on this one. I bought 1 32GB sodimm of RAM, thinking that I’ll buy a second one when the RAM prices go down (the current AI trend has caused RAM prices to more than triple). But the single sodimm really hurts any memorybound operations. In particular AI training/inference and gaming: two things I’m doing a fair bit right now. For gaming I’ve read benchmarks that dual dimms can up the framerate of some games by about 10-20%.

Even if I buy a second one, I believe I will end up with a higher amount of ram anyway (probably maxing out at 128GB if possible, past the theoretically supported 96GB for the AI 9 HX 370).

I’m considering buying a second smaller DIMM the first 16GB could be dual-channel, but then I would rely on how functional the processor is load-balancing across uneven sizes of RAM.