David Chico Pham | Cooking Code and Eating Knowledge

2026-10-08T19:50:39Z

Rethinking AI - JEV as realtime intellience in code

2026-10-08T00:00:00Z

Notes on Mega.dev workshop on JEV:

The user input does not go into LLM, but into JEV

if you give JEV to infer on, you can throw all conditions at the same time. You can discard that don't matter and apply logic that matters.

As you preload, as things float the top, you can pick what is most relevant.

Support emails to 1 of 4 teams?

Haiku v JEV
JEV finishes way before Haiku

A system one model, after the fast thinking in pyschology

Typesafe AI -> Confidence routing

Confidence score sets one floor per action

How can we apply JEV and it's confidence scoring to privacy engineering?

AI can be so cheap (JEV) it can be difficult to measure. JEV will go barely gong

Categorize email, bulk data, toss any questions against it. If below a threshold, you can automate. Above a threshold, defer to a person as a fallback. A default if a function does not match, is to defer to a person.

Logs can capture what falls through and you can evolve the code.

The speed is almost instantaneous. What to build realtime AI? Its faster than human perceptions. Debouncing is important.

Browser use Demo: Chrome extension

John L. speech to text searching for flights.

For typing, has to hand off to Haiku. You can take this approach and hand off to anything visual

Catchpoint tests, turbo charged.
e2e tests turbo charged

Smart time to pick from the UI elements

doing multiple things at the time

You get this experience, and saying things to wanting to happen. UI needed to show what is happening. When building ux, providing animations to convey what is occurring -- because it's too darn fast!

Things are developing into a game loop. Its becoming much more interactive experience and less of clicking around.

breaking down a sentence.

It's important to see, all questions are answered at the same time. When you have a little data, what do you need to ask it in order to get where it needs to go in relation to buckets (to match in db)

Think of your job, the content of the menu and how it's strucuture, and customers are placing orders in human speech. Your job is to set up the menu and instructions. Think yourself what questions are asking. Skills that Typesafe shares is a cookbook, you can JEV a question.

Ask questions that could applied, known as Speculative Fan out (TypeSafe)

Search hours of video in one video

six youtube videos. its going to do video processing. Fire a question, based on each video's transcript

Find the exact portion each video

Taking each chunk and reassemble into a one video

another round in answering if the filer stays or drops?

3 rounds, eight requests in blazing speed.

Composite scoring

The ranking lives in your code. the weights

Different from keyword finding because it's inferring from words. A smarter search

Wikipedia ends up in philosophy

JEV uses wikipedia api to find philosophy

Agentic engine optimization, to find the broken paths or fastest paths to get from A to B. thinking about the users.

Which one gets you closer to philosophy?

this is throwing JEV, whatever is user or agent facing, crawling and walking arrive it's destination using every navigate it on the page. You can surface your project, or UI like dropdowns, you can ask JEV to test for you. User test is still necessary. You can tell Opus make up 50 case scenarios, JEV can surface where the tensions and friction is.

send three robots at a job

Functions and with state

There is a lot tasks that depends on state (like time), that might block a function the agent uses and blocks them. This allows for a router to get to task.

JEV makes the judgement calls and the code does the rest.

Share a plan, in queue order
Planning the building data model needs reasoner

Mechanical changes, the builder 1 and 2 can take on those.

Kind of like a dynamic state machine.

What about a lot tasks to choose from, or has similar tasks?

intent routing

JEV, a date parser and router for plain code

narrows the task list to a few candidates

The list stays short, narrow it in code first and it needs to be deterministic keep it code

JEV makes the quick decisions. JEV does not replace for everything. Avoid forcing it in things that have been solved in traditional programming.

Todo app, matching app and narrowing down for JEV to pick from. JEV will get more expensive. It's meant for quick questions with messy data and messy users.

before you ship

Every message walks through JEV

log how JEV walks. Code the path and avoid using JEV

Four patterns TypeSafe cites in their docs

Pave what repeats:

Cheap: JEV and Perplexity option

A little smarter, but 10x the cost. JEV has the best balance. As any product, they are going to try to win over users.

John L. spent $6. millions of requests. A dollar will translate a month of usage

OpenRouter? look into it. Between it's decisions can vary in scores by decimals. You won't be able switch JEV to another thing because it may work differently. There is statical anonomlies.

Your product is your factory; your factory is your product. You can point a video and analyze and Opus will reverse engineer it in 15 minutes.

mega.dev next things

Personal software is easy. Production good software is much more difficult.

Dog fooding and caring about your users
If you don't use the tool, it will show.

Managing software with agents. Feedback systems conversing with your team and getting back with agents is critical.

you can do research with similar products and surface the pain points.

You can customize the tools on the terminal level and build tools for teams.

Read the article at Rethinking AI with Jev: Instant, Nearly Free, and Unlocking Whats Next

How to design a rate limiter

2026-10-07T00:00:00Z

Token Bucket algo takes two parameters

Bucket size: max number of tokens allowed in the bucket.
Refill rate: number of tokens put into the second per second

How many buckets do we need? It depends!

Different buckets for different API endpoints

Leaky Bucket Algorithm

Leaky bucket takes 2 parameters

bucket size: it is equal to the queue size. The queue holds the requests to be processed at a fixed rate
outflow rate: it defines how many requests can be processed at a fixed rate, usually in seconds

Shopify uses this algorithm

Memory efficient given the limited queue size
If you have a stable outflow rate, the fixed rate works well

But

burst of traffic fills up the queue with old requests, and if they are not processed in time, recent requests will be rate limited
just 2 parameters makes tuning and calibrating more difficult.

Ai Agents that never sleep instructed by Scott Moss

2026-09-29T00:00:00Z

Building custom harness

https://master.dev/workshops/background-agents/
https://github.com/davidpham5/xeno-agents
https://github.com/Hendrixer/background-agents

what is background agent?
agent handles the job. background agent activates task from events from the outside. It does not have to. They are the real productivity unlock. You can always going as fast as your prompt.

The best way to increase productivity is a machine does the work of a team and when to do the job and how to the job well.

A background agent is to reach a state. The BA is to reach the state. BA more durable. It is as if you asked someone to go figure out work arounds to blockers.

Who has the authority now? Fully auto mode? Add to a block list? add to a allow list. who has the authority to recognize permission.

What the LLM to do versus what the harness to do. The harness is deterministic.

The thinking framework: Observe, Decide, and Act Loop. Similar to how most Agent frameworks work today. No tooling calling today. We can have agent wait on background actions

It usually can't suspend. state might changed. connection closed.
Wait period, no compute is being used.

get a neon new db
openapi secret key

npm run db:push
npm run preflight # you have dependencies ready
npm run db:seed

Spin up a few things now:

Set up agent endpoint to run the agent.
Run the web app
Actual checkout service
--> all in package.json

ingest spins up the endpoint
npm run dev:checkout to spin up the checkout service

if you want watch instead live code, you can git switch lessons or ask the agent to get you caught up.

What if we build an environment that provides more intelligent context. For example, screen shots and point out things in the screenshot. For this project, is the state of the server. Snapshot that and let it act on that.

Observing the current world is something the agent does not get to decide that. The agent will choose action, based on historical actions. The next action is to say i am done? or ask for help? or learn more?

Harness then validates and executes. Avoid losing important data, money, etc. Rollbacks are destructive. It does not distinguish a person doing the rollback or a machine.

mock a fault

npm run dev:checkout -- --fault feature

we are going to building a custom harness.

Inngest: how you can make your code durable.

agent-workflow

redux reducer pattern

LLM part is the easy part. It's the harness is where the hard work because thats the interface for LLM

Structured Outputs -> ai engineering course. return a promise to handle a output you defined. decisionSchema in agent-brain.ts

JEV will be good for what is the likely actions. JEV wont generate new tokens for a new argument Not a drop in replacement. new archiecture is needed.

Tool loop, not ready to answer, so it calls other tools or infra.

at some point break the loop and the harness
revisit AI engineering to go over structured inputs and outputs.
also look into freecodecamp's building a harness from scratch

agents-workflow summary
if not any the return events, it will keep looping. Maybe we can't close the gap in reasoning, we need to have an agent reach for the LLM.

lets spin up the entire service:

"dev:checkout": "tsx service/checkout.ts",
"dev:operator": "INNGEST_DEV=1 tsx watch server/operator.ts",
"dev:agent": "INNGEST_DEV=1 tsx watch server/agent.ts",
"dev:web": "vite --host 127.0.0.1",
"dev:inngest": "inngest dev -u http://127.0.0.1:3002/api/inngest",

an action that stops the loop or terminates the loop

double check you ran the fault,

npm run dev:checkout -- --fault feature

Inngest has a cool dashboard.

what actions require a human to judge what to do?
what guardrails, that has infrastructure implications

"It's a like a state machine"

you can check in the inngest server dashboard at http://127.0.0.1:8288/runs

add act step in agent-workflows

A step is much like a useMemo. Re-executed loop. Step is something that is expensive and we want it save deterministically

// this is going to hit our LLM. You often wants to put this in a step because this cost money/tokens

// we do not want LLM at top because its probalistic and its different every time.

// thinks a step is a useMemo() in react.

const decision = await step.run(`choose-action-$cycle}`, () =>

chooseAction(run.goal, state),

);

we do not want to put LLM outside of a step

tool-policy
different type of policies we have.

steps should be idempotent because you don't want execute an action over again and change the state.

validate stuff. its just on and without prompt

lesson 03
there is an incident but we don't have enough information, so wait for more info. or we've seen this error before and we can ignore, but if we see this other error, then do something.

a dependency may recover while the agent is idle. Doorbell by event. it may go back to sleep before there is more.

We want the model to choose to wait. we can force the agent to wait.

if 3rd party dependency, does the agent ask for help or wait or what? there are many cases an agent will wait.

timeout is 3 days! thats why these steps have to be deterministic. Inngest docs.
Treat this step as async function and not suspending the call stack.

The inngest.createFunction() wraps the workflow in a deterministic shell. Everything inside it must be deterministic, outside a step(). Instead, the steps themselves have to be idempotent. So what does that mean? If the workflow was based on date and it responds to dates, its not deterministic.

lesson 4 Human back in control

The agent can signal that it needs help.
Inngest has docs to bring humans in the loop. They treat slack as their inbox instead of building an inbox

Human Ai decision making can skew Ai's actions. Don't tell it that you reviewing it.

Approval is not a universal safety shield

De-risk or build a rollout mechanism. looking at a inbox and why are you doing that.

AgentDojo: read the paper about prompt injection by using human in the loop

we take a snapshot of the snapshot for the state. You may get different results if you run this

Does the state drifted so much when the proposed action was brought forth.

const proposalId = await step.run(
          `propose-action-${cycle}`,
          async () => {
            const proposal = await proposeAction(
              environmentId,
              runId,
              actionId,
              decision.action,
              input,
            );
            return proposal.id;
          },
        );
        // why create a proposal to only get the id and then here
        // and then make a proposal here?
        // because proposal overwrite. Get variable from DB and not cache value at some point
        // Getting stale proposals from the above will lead to a bug
        let proposal = await step.run(`read-human-${cycle}`, () =>
          getProposal(proposalId),
);

we got an inbox notification!
we finished approval request
and approved
Run completed!

lesson 5 - Idemopentecy
Aws has good doc on it: https://aws.amazon.com/builders-library/making-retries-safe-with-idempotent-APIs/

stripe won't make transaction happen more than once. because it has idemopotency

read the papers from the Labs and challenge you that you have not thought about. With the help AI, slowly insight appear. Connections can then be made.
Replicate some of the experiments
you will be ahead of the game.
Scott Moss has used research papers in his Netflx job. Then he'll communicated it. His team then will share that worked a bit!

Read the article at Ai Agents that never sleep i

n8n for blogging is back, baby

2026-05-02T00:00:00Z

I want to set up a n8n self hosting instance on my server and run a marketing funnel for this site. I want to present a pop up like substack to subscribe to a newsletter and build an audience. And at the end, turn some readers to paid members.

Part 1: Self-Host n8n on DigitalOcean

1.1 Create a Droplet

Log into DigitalOcean → Create → Droplets
Image: Ubuntu 24.04 LTS
Plan: Basic, $6/mo (1 GB RAM, 25 GB SSD) — sufficient for n8n
Region: NYC1 or closest to you (East Coast)
Authentication: SSH key (recommended) or password
Hostname: n8n-server

1.2 Install Docker + n8n

SSH into your droplet:

ssh root@YOUR_DROPLET_IP

Install Docker:

apt update && apt upgrade -y
apt install -y docker.io docker-compose
systemctl enable docker

Create n8n directory and docker-compose file:

mkdir -p /opt/n8n && cd /opt/n8n

Create docker-compose.yml:

version: '3.8'
services:
  n8n:
    image: n8nio/n8n
    restart: always
    ports:
      - "5678:5678"
    environment:
      - N8N_HOST=n8n.davidchicopham.com
      - N8N_PORT=5678
      - N8N_PROTOCOL=https
      - WEBHOOK_URL=https://n8n.davidchicopham.com/
      - GENERIC_TIMEZONE=America/New_York
      - TZ=America/New_York
    volumes:
      - n8n_data:/home/node/.n8n

volumes:
  n8n_data:

Start n8n:

docker-compose up -d

1.3 Set Up Domain + SSL

Point a DNS A record for n8n.davidchicopham.com → your droplet IP.

Install Caddy as a reverse proxy (handles SSL automatically):

apt install -y caddy

Edit /etc/caddy/Caddyfile:

n8n.davidchicopham.com {
    reverse_proxy localhost:5678
}

Restart Caddy:

systemctl restart caddy

Wait a few minutes for SSL provisioning. Visit https://n8n.davidchicopham.com — you should see the n8n login screen.

1.4 Verify

Log in with the basic auth credentials you set
Create a test workflow with a Webhook trigger node
Copy the webhook URL — you'll need it in Part 3

What is n8n? It's like Zapier or Make, a canvas drag and drop flow chart that can build triggers, actions, and output stuff. It's source can be self hosted or through paid cloud account.

Master 80% of n8n in 36 Minutes - YouTube

There is a number of actions a trigger could attach to. Actions are apps like dropbox, google sheets, or airtable. It occurred to me that a level of automation could happen in organizing. For example, when we were recruiting for elected officials or stewards, we used a conversion logger that fed into a google sheet.

If that conversation was an assessment, e.g. how interested are you in becoming a steward, a scale from 1 to 5, 1 being LFG to 5 being don't ask me ever again -- a friend said politely to me that he was not interested in further involvement with the union and didn't want to be asked again -- that's a 5, then based on that assessment, follow up automated email is sent a couple days later with an ask for a 1 on 1.

Or how about an outreach plan triggers a text/phone bank.

I can imagine also a directional change could be tracked like when voters switch from republican to democrat, visualized with arrows on a map of congressional districts, but for assessment conversations.

Another example in n8n development and organizing is something like a virtual organizer. Imagine the system prompt had the role of someone like Jane McAlevey (rest in power) and you can ask how did a conversation go and what are next steps to organizing a person. Instead of a AI personal assistant, how about a personal co-organizer?

Structural tests can be signals to who is engaged. It reminds me of the like button by Facebook that sent a signal to the platform, or even the skip button on youtube is a signal. What about structural tests such as an emoji response?

plugin, superpowers used to plan newsletter component.

To achieve substack fade to popup as a user scrolls down content, Intersection Observer API - Web APIs | MDN will observe an element threshold to which the popup will come into view. Once that threshold is hit, the observer will disconnect. Notably, intersection observer solves for implementing infinite scroll.

Current song on the iPod: Thnks fr th mmris by Fallout Boy

Where does this stack hook into plausible.io? Maybe via n8n

How to handle errors:

Error Handling

Failure	What user sees	What system does
Honeypot tripped	"Thanks — check your inbox" (lie)	Edge fn returns 200, no Buttondown call, no n8n call
Submit <2s after popup shown	Same as above	Same — silent rejection
Invalid email format	Inline form error: "Enter a valid email"	Edge fn returns 400, no downstream calls
Buttondown 5xx / network error	"Something went wrong, try again in a moment"	Edge fn returns 502; no localStorage write; user can retry
Buttondown "already subscribed" (400 with `email_already_exists`)	"Thanks for being a subscriber"	Edge fn returns `{ ok: true, already: true }`; localStorage marks subscribed
n8n down (submit path)	Success (Buttondown succeeded)	`Promise.allSettled` — n8n failure logged, doesn't affect user response
n8n down (event-only path)	Nothing	sendBeacon fires fire-and-forget; events lost — acceptable
User has JS disabled	Popup never shows; inline form is inert HTML with `<noscript>` link to `/newsletter`	No subscribe path; acceptable degradation
localStorage blocked (private mode)	Popup may show repeatedly across sessions	Acceptable — small audience, graceful degradation
Edge function down	Submit fails with network error; user sees retry message	No silent data loss

NodeJS API Design

2026-04-27T00:00:00Z

One of the things I am weak at as a fullstack engineer is the backend. I very comfortable in developing interfaces for users. I'm much more confident in CSS, HTML, and JS than I am in NodeJS and Express.

For the past 3 weeks, I've been going through Frontend Masters NodeJS API Design, presented by Scott Moss of Netflix. It's really helpful in understanding the backend.

Here are my notes:
04-02-2026

https://frontendmasters.com/courses/api-design-nodejs-v5/node-js-servers-overview/
https://api-design-with-node-v5.super.site/
NodeJS primary purpose: build servers, access file systems, interact with databases
API: file system, networking, process management, crypto
secuirty: you roll. your own. DENO has an optin to security

from a frontend perspective

the mental model shift
you write fetch() and assign results

const data = await fetch('/api/users')
const users = await data.json();

backend perspective

app.get('/api/users', async ( req, res) => {
	const users = await db.query(
		'SELECT * FROM users';
	)
	res.json(users);
})

the browser gives us free security
you can natively use ES modules in the browsers

Serverless Functions

allows for functions to fire when api hits it. They don't have to be always on but this comes at the cost of speed. something like web sockets is that lives long cant use serverless.

CDN

You can write pure JS now on CDN. 10 years ago you could do some logic but nothing like scripting

Edge function is programmable CDN

background job

async job. tasks that run outside the request-response cycle

send email
processing images
data sync
heavy computation
They have less to do with the user and more to with architecture choices

Cron job

A type of background job that runs at an interval

What is an HTTP verb in the context of server routing?
An HTTP verb is an action or type of request indicating the desired operation to be performed on a server, such as GET, POST, PUT, DELETE, etc.

env

an important thing to know about .env is that when we use process.env.SECRET the value is rendered at runtime for client side frameworks. Sure you have it shared in github but it's exposed still.

It's a great way to change configuration without changing your code. the EQUIVALENT on the frontend is a feature flag.

They allow dynamic value changes without hard-coding variables, making it easier to manage different settings for staging, production, and local development environments

this is not type unless you look at .env. they can be a lot env variables. so how do we keep track of them? https://frontendmasters.com/courses/api-design-nodejs-v5/dev-production-variables/

challenges with env:
They are not typed, and it's difficult to know which ones exist without checking the .env file or consulting an experienced team member

Why create multiple .env files like .env, .env.example, and .env.test?
To separate environment configurations, keep secrets out of version control, and provide example variable names for team members while allowing different configurations for testing

Zod
Zod provides runtime type-checking and schema validation, allowing verification of environment variable types and presence at runtime

Rotating Secrets
What is a strategy for managing secrets and sensitive configuration values?
Rotate secrets periodically, use secrets management tools like HashiCorp Vault, and avoid hardcoding sensitive information

understand HTTP routing

it's combination of a verb and path pattern

verb	purppose	example	expected result
GET	fetch data	GET `/api/users`	list of users
POST	Create new resource	POST `/api/users`	create new user
PUT	update (replace) entire resource	PUT `/api/users/123`	User 123 completely updated
PATCH	partial update	PATCH `api/users/123`	user 123 partially updated
DELETE	remove resource	DELETE `/api/user/123`	User 123 deleted
if you do graphql, you care about POST requests

what is RESTful
for every 'resource', like tags, user, comment, file, you will have a CRUD routes on a resources
https://frontendmasters.com/courses/api-design-nodejs-v5/http-verbs-restful-route-patterns/
GET === READ
POST === CREATE
PUT/PATCH === UPDATE
DELETE === DELETE

if you need a concurrence of resources, and therefore need to call a few APIs, you may overfetch. GraphQL provides a way to query many APIs and get the exact data you want. the trade offs are significant: permissions, cache, query optimizations

RESTful API is a beautiful thing because we just agree to it and built CRUD apps that serve the web for everyone.

The server provides a level of freedom a frontend dev does not have. A backend dev tells you want the routes are and how they are defined

Routes

Sub-routers are individual routers for specific resources that can be mounted onto a top-level router. They are typically created by importing the Router from Express and are organized by resource type (e.g., User Routes, Habit Routes).

typical CRUD routes for a Habit resource include: GET / (get all habits), GET /:id (get a single habit), POST / (create a habit), DELETE /:id (delete a habit), and potentially custom routes like POST /complete/:id.

Mounting via `use`

https://frontendmasters.com/courses/api-design-nodejs-v5/mounting-routes-with-use-middleware/
use is for no http verb related to the route. It's a way to apply an action to a route. For example, dev wants to hit /api/auth, instead of a callback like (res, req) => {} we use our authRoutes

import authRoutes from './routes/authRoutes.ts'

app.use('/api/auth', authRoutes)

Anyone who hits a route, defined in authRoutes, /api/auth/register then use that handler. .use() handles all HTTP methods for a given route regardless of the specific verb. Subroutes allow you to mount routes under a specific base path, so a route like /register under /api/auth would become /api/auth/register

Mounting allows you to specify a base route path for a group of routes, so routes can be decoupled and easily relocated without changing internal route definitions

Middleware

NextJS has middleware.ts
edge functions on the network layer before the server
CDN edge functions

HTTP interceptors -> axios fetch, apollo interceptor

our foucs is backend middleware
using use() without a path is known as global middleware, e.g. logging
how is middleware built?
Express, middleware is left to right. if you are going to respond, in middleware, don't run next()
simply it's an array of functions. each function is wrapped in a next() function. Its known as a controlled loop.

understanding `next()`

doing a side effect like analytics log

another good example of middleware is credit card check, like expiration date is checked
passing an arg in next() will be handle by Express as an error
error handling is just middleware too

The dominate pattern: (req, res, next)

What is the recommended practice when responding inside middleware?
Always call return after responding, unless it's the last line of code. This prevents subsequent code from running after the response has been sent.

CORS

Options request -> preflight
allowList? unless you are writing in the server
helmet security package
morgan is a request logger

validate inputs:

https://frontendmasters.com/courses/api-design-nodejs-v5/validation-middleware/

to avoid checking them with a bunch if/else statements

asnyc middleware wrapper: avoid wrriting a lot of try-catch statements, and instead wrap it in a function curry
https://frontendmasters.com/courses/api-design-nodejs-v5/async-middleware-pitfalls/

Databases

https://frontendmasters.com/courses/api-design-nodejs-v5/database-schemas/

Migrations: they suck! https://api-design-with-node-v5.super.site/4-db-setup-and-schema
Think of them as database versioned.
Migration Workflow:

Develop: Make schema changes in code
Generate: Create migration files automatically
Review: Inspect generated SQL before applying
Apply: Run migrations against database
Deploy: Apply same migrations in production

If you can find a way to do only non-destructive changes, then make your life a lot easier

ORM Benefits for APIs


Benefit	Description	Impact
Type Safety	Compile-time error checking	Fewer runtime bugs, better DX
Query Building	Programmatic query construction	Dynamic filtering, pagination
Relationship Loading	Automatic joins and includes	Less code, optimized queries
Schema Management	Version-controlled database changes	Reliable deployments
Migration System	Automated schema evolution	Safe production updates

Migrations: Database Version Control

Migrations are versioned scripts that modify your database schema over time:

Drizzle vs Other ORMs

Why Drizzle Over Prisma?

Prisma Approach

// schema.prisma
model User {
  id    String @id @default(cuid())
  email String @unique
  habits Habit[]
}

model Habit {
  id     String @id @default(cuid())
  name   String
  userId String
  user   User   @relation(fields: [userId], references: [id])
}

Requires:

Schema definition in Prisma language
Generated client (prisma generate)
Build step in deployment
Black box query generation

Drizzle Approach

// Pure TypeScript schema
export const users = pgTable('users', {
  id: uuid('id').primaryKey(),
  email: varchar('email', { length: 255 }).unique()
})

export const habits = pgTable('habits', {
  id: uuid('id').primaryKey(),
  name: varchar('name', { length: 100 }),
  userId: uuid('user_id').references(() => users.id)
})

Benefits:

Pure TypeScript - no DSL
No code generation step
SQL-like API - predictable queries
Lightweight and fast

Implementing the Schema

refer to coding project
File: src/db/schema.ts

Habits Table schema
key features:

foreign key with cascade: when the user is deleted, their habits attached to them is deleted as well.
frequency system: flexible habit scheduling, e.g. daily, weekly, monthly
target count: support habit like "drink 8 glasses of water daily"
soft delete: isActive allows hiding w/o losing history

many to many relationship

export const habitTags = pgTable('habitTags', {
  id: uuid('id').primaryKey().defaultRandom(),
  habitId: uuid('habit_id')
    .references(() => habits.id, {
      onDelete: 'cascade',
    })
    .notNull(),
  tagId: uuid('tag_id').references(() => tags.id, {
    onDelete: 'cascade',
  }),
})

The point of this habitTags is that I can query habitId and see all the tags associated with that habit and vice versa. If I want to see how many tags have habits, I can query the above table.

What is the purpose of a unique index in a database schema?
A unique index allows quick data retrieval and ensures that no two records have the same value in the indexed column, preventing duplicate entries like emails. It helps locate data quickly in constant time without scanning the entire table.

What is the primary purpose of using UUID as a primary key?
UUID (Universally Unique Identifier) serves as a unique, randomly generated identifier for database records, providing a globally unique value that can be generated without potential conflicts across different systems or databases.

How does a foreign key relationship work in a database schema?
A foreign key creates a link between two tables by referencing the primary key of another table, establishing a relationship. In this schema, it allows actions like cascade delete and enables querying related entities across different tables.

What is the benefit of using a join table for managing many-to-many relationships?
A join table allows flexible and normalized data storage by creating connections between two entities, enabling bidirectional querying. It helps manage complex relationships by storing links between related tables without directly embedding foreign keys.

Edmund Edgar - Bluesky, atproto, how to hack on it and why it matters

2026-03-31T00:00:00Z

Protocol Berg v2: Edmund Edgar - Bluesky, atproto, how to hack on it and why it matters - YouTube

The PDS v My Old Web Server

Structured data
- web server was for document data
attached to an identity
contained the social graph
- all the entries can refer to other entries on other pds's
cryptographically signed and content addressed.
- you dont have to get all the content from the person
you can self host on a crappy vps, you get viral and your pds can stay up because not going get a data from pds

The Job of the Relay

to get the latest changes from the various PDSs and put them in a massive stream known as the Firehose.
Run you run a bunch of a appview which are backend servers.
Bluesky is running them but also other people are running their own.

what happens when you post on bluesky

Assign an id, cid hashed to make a CID.

Encoded with DAG-CBOR: a compact binary way encoded structure data and easily roundtrip with json, and easily pass. DAG is a subset of CBOR.

cid is Content Id

commit node on top and merkle root. and verify your content

identity

Two takes on identity
DID:Web predate at-proto and part of web standards. Just put a document on a web server
DID:PLC placeholder or Public Ledger of Credentials ( created by at proto team)

We want to get close as we can to Content REST data. Take the doc that tells you what you need to know about my identity.

Put in username
put in key that controls the identity
hash on the first update

sign with a key in the previous rotationKeys. If you got a chain of updates, and can be verify
Trade Off
if you change your roationkey and someone got your hold of your key, no one could tell when a malicious line of updates goes through - At proto team handles this with a trusted sequencer

missing features means one dominate client ( like facebook )

Curation -> for you feed. "Discover" tab
- anyone can make a feed
- its easy. listen to changes to the firehouse. pick up the users ids and iterate a bunch ids and any user can take that feed.
- you can make block list or follow list

what else can we do with atproto

Everyone in the world gets a self-sovereign crypotgraphically verifiable semantic data store. This is what we should have done

You can write records on the user behalf to their PDS.
You can auth via OAuth
Oauth flow can create a new account on a PDS host
you can onboard the user to atproto

lexicon

You want to follow a lexicon

decentralized github -> tangled.sh
PR tracking
instead of github its on your own git on your PDS

blockchain -> commons data
you have limit who can write to the blockchain

You need data written by the user and owned by the user.

Read the article at link

Day 1: Setting Up This Is My Next

2026-03-15T00:00:00Z

This section is called This Is My Next — a dev log inspired by Fight With Tools. Each entry is a timestamped snapshot of what I'm building, what I'm stuck on, and what I'm figuring out.

The idea: short, honest notes. Not polished essays. Just progress.

What I Built Today

The whole infrastructure for this section in one sitting:

A new timn content type with its own layout
A TODO checklist component that reads from frontmatter
VS Code Dark+ syntax highlighting scoped to this section only
A Bluesky share button on every post
An archive page at /this-is-my-next/

Here's the 11tydata.js that powers the content type:

module.exports = {
  layout: 'layouts/page-timn-post.njk',
  contentType: 'timn',
  excludeFromFeed: false,
  eleventyComputed: {
    permalink: (data) => `/this-is-my-next/${data.page.fileSlug}/`,
  },
};

And the TODO frontmatter format looks like this:

todos:
  - text: Set up monorepo
    done: true
    subtasks:
      - { text: "Pick package manager", done: true }
  - text: Write first post
    done: false

Next Up

Collect and read links as recommend by Aram, and share as a post.

Why I'm Starting This Section

2026-03-10T00:00:00Z

I had something missing on my site for a while. I thought maybe /projects could serve as a way to deep dive into a technology, e.g. Astro or htmx.

The challenge was that I'd have starts and stops on a projects. I would end up forgetting what I was doing and didn't have a good way to kickstart a project. In fact last year, I developed deep sense of alienation from my work. I felt I didn't have any direction to pursue. I was bored and importantly, my work didn't feel like my own. Also the world is falling apart. That also distracted me.

Aram Zucker-Scharff's blog fightwithtools is a work log of his projects, that serves as a bit of inspiration. After chatting with Aram, he shared that the blog helps him organize his projects and allows him to pause for a period of time and pick it back up when ready.

I want that for myself.

This site has essays, storystreams, and turbocharged links. But nothing that captures the texture of building in progress. This Is My Next is that space.

The Rules

Share what I am learning as rough unedited progress logs.
The TODO section is stick and sits before the post
Learning for learning sake is fun

What I'm Working On

I am using Claude Code to build out features so I can write, discover, and share more. So to that end, I am exploring at-proto as the next big thing in web development. Claude Code is enabling a bicycle of my creativity, innovation, and ambition. I am aim to teach myself to take advantage of the tools of my peers and have this technology serve me and my goals.

Sleeping Deeply and Dreaming

2025-09-26T00:00:00Z

We dream in the dark. Darkness everywhere we see. Blind to what is to come next.

Fear and dread make our bed. Gentle heads slumber in the dead of night.

Do not wake me. I need to sleep deeply. I want to see what could be, dreams of democracy.