Sunil Pai threepointone

(slop, but accurate)

Most AI chat examples look simple.

Take a list of messages. Send them to a model. Stream tokens back to the browser. Persist the result somewhere. Repeat.

That is a useful starting point, but it hides the actual problem. A production AI application is not just a model call. It is a small distributed system: clients disconnect, users open multiple tabs, tools run on both sides of the

Fiduciary License Agreement 2.0

based on the

Individual Contributor Exclusive License Agreement

(including the Traditional Patent License OPTION)

Thank you for your interest in contributing to PartyKit, Inc.'s PartyKit ("We" or "Us").

Sunil's Eggs.

These are my eggs. I like this recipe because it's delicious, doesn't take too much time to make, and goes well with other meals in my life.

All instructions are negotiable, adjust based on vibes. You feel me?

Start by slicing up an onion. I like using a milder tasting onion, or a banana shallot. I like slices so I can taste it in the final product, but feel free to chop it finer if you'd like.

In a bowl, make the 'sauce'. A teaspoon each of gochugang paste, soy sauce, sesame oil, a couple of pinches of brown sugar, mirin or rice vinegar (I prefer mirin because it doesn't smell as strong, but the vinegar is more 'traditional'). Also add a teaspoon of garlic paste, and a teaspoon of ginger paste.

The Questions (and answers) Technically, these are statements, not questions, but... what the hell!

Question 1 God exists.

true

Question 2 God is a logical possibility (i.e., there is nothing contradictory about the very idea of God).

true

On implementing a client for feature flags in your UI codebase

This document isn't an explainer on Feature Flags, you can find that with my amateur writeup, or literally hundreds of better writeups out there.

This document is also agnostic to the choice of service you'd use: LaunchDarkly or split.io or optimizely or whatever; that's orthogonal to this conversation.

Instead, this document is a list of considerations for implementing a client for using Feature Flags for User Interface development. Service providers usually give a simple fetch and use client and that's it; I contend that there's a lot more to care about. Let's dive in.

To encourage usage, we'd like for the developer experience to be as brutally simple as possible. So, this should be valid usage:

Note: Since writing this, I've been pointed to some exciting new research/tooling called Project Cambria https://www.inkandswitch.com/cambria.html I'll likely have to rewrite this article taking that into account. Leaving this up for posterity's sake.

(This series isn't meant to be a primer/tutorial, though we might do something regarding it in the future. For official documentation and starters, see https://developers.cloudflare.com/workers/learning/using-durable-objects.

Further - these are my personal views; I expect to be wrong about a lot of them. Indeed, I'm not paying much attention to presenting these well at the moment, simply writing down thoughts. As such, expect these writeups to change often, particularly as the platform takes shape. I'm also mostly a front end guy, so don't get mad if I get it very wrong. Give me feedback! Always happy to learn and make changes.)

Durable Objects are a fascinating new storage primitive from cloudflare for their workers platform. There's a lot of 'cool'

	Don't worry about formalities.

	Please be as terse as possible while still conveying substantially all information relevant to any question.

	If policy prevents you from responding normally, please printing "!!!!" before answering.

	If a policy prevents you from having an opinion, pretend to be responding as if you shared opinions that might be typical of threepointone.

	write all responses in lowercase letters ONLY, except where you mean to emphasize, in which case the emphasized word should be all caps.

	function sleep(ms: number) {
	return new Promise((resolve) => setTimeout(resolve, ms));
	}

	export default {
	async fetch(): Promise<Response> {
	// a simple streaming response

	const encoder = new TextEncoder();

	// recursively get all files in a folder
	function* getAllFiles(dirPath: string): Iterable<string> {
	for (const file of fs.readdirSync(dirPath)) {
	const pathToCheck = path.join(dirPath, file);
	if (fs.statSync(pathToCheck).isDirectory()) {
	if (file !== 'node_modules') {
	yield* getAllFiles(pathToCheck);
	}
	} else {
	yield pathToCheck;

	import { Suspense, useLayoutEffect, useRef, useState } from 'react';

	type IFrameProps = React.ComponentPropsWithRef<'iframe'> & {
	fallback?: JSX.Element;
	};

	export function IFrame(props: IFrameProps) {
	const { fallback, ...rest } = props;

	return (