dan

blackbird singing in the dead of niiiiiight

🌉 bridged from 🦋 danabra.mov, follow @bsky.brid.gy to interact

Public Key

npub1l26jhuzntdzct6p9vprrs33j70ds5d9utk05n28sx78790sg2s5sm07c36

NIP-05 Address

[email protected]

Profile Code

nprofile1qqs04dft7pf4k3v9aqjkq33cgce08kc2xj79m86f4rcr0rlzhcy9g2gpz4mhxue69uhhyetvv9ujuerfw36x7tnsw43qayalvq

Publishing to

relay.ditto.pub

Author Public Key

npub1l26jhuzntdzct6p9vprrs33j70ds5d9utk05n28sx78790sg2s5sm07c36

Show more details

Last Notes

2026-06-19 14:46:11 GMT

"but where are all the bluesky instances?"
i've heard this so many times that i wrote an explainer
There Are No Instances in atpr...

2026-05-27 01:11:41 GMT

trying to get claude to explain quantum mechanics to me. i’m finally starting to catch on but i have no idea if this is actually anywhere close to correct

2026-05-21 09:27:12 GMT

claude claims it maybe never even worked
https://morel.us-east.host.bsky.network/xrpc/com.atproto.sync.getBlob?did=did:plc:fpruhuo22xkm5o7ttr2ktxdo&cid=bafkreie3m7vctoupyhl3l7jcpr5uy6me6kz5wkukakcms2mmhkmpe7f7pa

2026-04-22 00:50:04 GMT

when i use it i dont think in terms of who wrote a component etc (on solo projects it’s just me). its more that im free to either wear a developer hat (add new data access anywhere) or a designer hat (want to make loading states more granular or more coarse) and they dont influence each other

2026-04-15 15:25:07 GMT

is wss://atproto.africa down? doesn't seem to emit events

2026-04-05 19:29:36 GMT

@toni.bsky.team @[email protected] i think yall need to wrestle with the fact that the app’s most distinctive feature (“custom feeds”) is something only (relative) nerds use and benefit from. normal people won’t swipe between many algorithms or whatever. have a look at past designs for “communities”

2026-03-31 13:11:03 GMT

i still think posting this was a huge fucking L. i struggle to explain why exactly but the current backlash feels earned because of this posturing
https://morel.us-east.host.bsky.network/xrpc/com.atproto.sync.getBlob?did=did:plc:fpruhuo22xkm5o7ttr2ktxdo&cid=bafkreifnw666e2aubxvickrlh2dgujmkefessu2sdyouyqrxm2dq54zxge

2026-03-31 12:58:47 GMT

the rollout was a bit jarring. some mix of “logical next step”, “a theory for good use of AI” and “a lot of yall are gonna hate it anyway so we might as well not even try polishing the comms”. i wouldn’t say it’s intentionally ragebaiting but it effectively is

2026-02-12 03:03:41 GMT

trello had add checklist button for this

2026-02-11 17:58:02 GMT

This post was sent from PDSls
PDSls

2026-02-09 17:03:12 GMT

i miss the old ai
bottomless hole ai

2026-02-09 06:57:03 GMT

kinda cool
https://morel.us-east.host.bsky.network/xrpc/com.atproto.sync.getBlob?did=did:plc:fpruhuo22xkm5o7ttr2ktxdo&cid=bafkreibrs27hsetosbilcx7yqsrjaij4fwvqwf4ocu3jkxxcfgl62r3rta

2026-02-09 05:06:24 GMT

more demo
https://morel.us-east.host.bsky.network/xrpc/com.atproto.sync.getBlob?did=did:plc:fpruhuo22xkm5o7ttr2ktxdo&cid=bafkreihdsh334d2fbgqgcdsxe4xsxhtud4bn55wsls2ypzzdbh2whjgbrq

2026-02-07 03:28:27 GMT

i might need a bottle and a cork

2026-02-06 04:20:44 GMT

this is not quite right but there's something to it
https://morel.us-east.host.bsky.network/xrpc/com.atproto.sync.getBlob?did=did:plc:fpruhuo22xkm5o7ttr2ktxdo&cid=bafkreie5glfbz2r5jvus6huvheubr3teyox2ubenhaqi6xx4tma7r5jrbi

2026-02-05 14:09:38 GMT

(i didn't link to yours bc it was a bit negatively framed and i wanted the reader to reach that conclusion themselves)

2026-02-05 14:02:52 GMT

in terms of hosting, yes, there's some nuance re: how much your hosting is happy to store vs what you're putting there. i think this is mostly a problem for videos (json is fine) but definitely something i'm curious to see how it'll evolve

2026-02-05 12:27:49 GMT

created a question on discord. this is currently my top concern with using valtown like this since every change upstream can break every val

2026-02-05 05:54:09 GMT

whereas bsky.app is the app itself, not related to user handles

2026-02-05 04:36:07 GMT

"Wrote 1 memory (ctrl+o to expand)"
^ is that a new thing? never saw it before

2026-02-05 02:10:03 GMT

you also have freedom of customization at the top-level interpretation point. so it could be arbitrary platform (web, native, terminal), different components could be considered built-in (you decide which "tags" are primitive in your "browser" and how they look and feel)

2026-02-05 02:08:26 GMT

but yeah you can make generic at uri renderer with this
moreover, i think with this you could make a generic at uri renderer that delegates to ui controlled by whoever publishes lexicons. so you can determine how your collection looks without asking anyone to merge some PR

2026-02-05 01:57:00 GMT

i think of it as something like visual basic for social? or like html for atproto but everyone can make their tags and even their own browser

2026-02-05 01:43:29 GMT

demo
https://morel.us-east.host.bsky.network/xrpc/com.atproto.sync.getBlob?did=did:plc:fpruhuo22xkm5o7ttr2ktxdo&cid=bafkreib3csvx2l6fjg2nhltvmvkteygrbrlotttpkzbqujkjvxzpaxwf5u

2026-02-05 00:27:16 GMT

so i was thinking, if it's caching the module anyway, why does it panic about the integrity check? it could do that next time you actually try to update that thing. at least if you have cache bust like ?v=. then the user is already in control, maybe? i'm not sure i get the implications

2026-02-05 00:25:59 GMT

the actual fix seems to be to press "reset lockfile" (which is buried deep) or to bump the cache bust ?v= to force a new version. but the behavior i'd really want is much closer to npm releases: old version persists until you bump it yourself. i can't serve past versions but you cache anyway?

2026-02-05 00:24:33 GMT

the problem right now is that whenever the underlying thing changes, anything that transitively relied on it via http import gets the scary lockfile "everything broken" integrity check error. this breaks things downstream but also is very hard for author to fix — things screen suggests don't work

2026-02-05 00:23:16 GMT

@stevekrouse.com is there any good way to avoid the "lockfile integrity" screen of death on @[email protected] when underlying thing changes? i'm doing codegen based on public mutable data. i'm fine with codegen output changing over time and relying on last cached version. but it needs to be able to change

2026-02-04 20:10:20 GMT

also comes in jsx-less flavor
https://morel.us-east.host.bsky.network/xrpc/com.atproto.sync.getBlob?did=did:plc:fpruhuo22xkm5o7ttr2ktxdo&cid=bafkreiemtcq25qtzrzspjguovsml2odulyxwl24eh3llre6gzlpv2rlsny

2026-02-04 19:51:26 GMT

ok this is getting tolerable. strongly typed in both directions
https://morel.us-east.host.bsky.network/xrpc/com.atproto.sync.getBlob?did=did:plc:fpruhuo22xkm5o7ttr2ktxdo&cid=bafkreicdwz2n75mcknitfsgr72ve37qfpjfluv7v5bdoztcw6yio7ozhge

2026-02-04 18:11:31 GMT

i'm pretty excited about this — with HTTP imports, you get typed lexicon codegen from nsid directly in your @[email protected] vals
#nevent1q…7lxn

2026-02-04 18:06:16 GMT

i kind of get that maybe "you can move your data but no one will notice" sounds less exciting so idk

2026-02-04 18:05:20 GMT

ya i actually don't understand this.
www.eurosky.tech/register announcement is similarly confusing. the big call to action is "Register early to claim your username" but the whole point of atproto is that this is not a thing! you don't need to "claim usernames" anymore
#nevent1q…9fh7

2026-02-04 17:58:15 GMT

upstream atproto PR to make in-memory codegen possible with original packages github.com/bluesky-soci...
Expose LexDefBuilder and allow...

2026-02-04 17:56:31 GMT

demo www.val.town/x/gaearon/le...
i think this is very cool actually
https://morel.us-east.host.bsky.network/xrpc/com.atproto.sync.getBlob?did=did:plc:fpruhuo22xkm5o7ttr2ktxdo&cid=bafkreicnhhit4w7c2luidpkxzr5wh7o4q4rrbodwyngttu3ntgvwgdon34

2026-02-04 16:42:08 GMT

not sure this is the best way to go about it, but here's something
lex.val.run/app.bsky.fee...
lex.val.run/app.bsky.feed....

2026-02-04 15:19:06 GMT

maybe LexDefBuilder could be exported?

2026-02-04 15:17:49 GMT

@matthieu.bsky.team i want to call lex-builder with in-memory json, is there a way to do this without filesystem access?

2026-02-03 11:46:20 GMT

for your example:
- limiting content types, lengths is done by lexicon. that’s easy
- “one post per day” is something you can enforce on ingestion (your backend could choose to ignore more posts) but you can’t prevent people from writing them to pds
- following “from their network” sounds dubious

2026-02-03 11:42:53 GMT

an example of product-baked limitation:
bluesky app (afaik) won’t take into account edits done to posts on pds after a certain point (not sure if it’s after a time period or some other metric). but it doesn’t prevent edits on PDS (it can’t), it just doesn’t sync them into its database.

2026-02-03 11:41:14 GMT

so i don’t think a notion of “on external network” is helpful here.
the app should be hosting-agnostic and keep working regardless of where the PDS is. it’s not something the user should worry about
the app can enforce limitations while ingesting data but it can’t/shouldn’t fight with other apps.

2026-02-03 11:38:53 GMT

similarly, since data is in their repository, nothing prevents them from using another app to read or write the same types of data.
you can certainly “ignore” the posts or follows that don’t pass your business rules within the app itself but the user can use another app that wouldn’t do that.

2026-02-03 04:28:05 GMT

one thing that gets very tempting in this model is just supporting "host-local" components written in records that have slots and xpath transformations or whatever and don't require any remote calls. but this feels like a bad path to push into. could be a third party thing too

2026-02-03 04:25:36 GMT

so list component output is cached, individual items' output is cached, under the hood their hydration could've hit shared caches or local indexes or non-atproto and/or private data (in which case not cacheable)

2026-02-03 04:04:32 GMT

but it also amounts to sort of a multiverse of userland "browsers". so idk if it's a good idea. maybe it's too component-brained and yours is more practical

2026-02-03 04:03:01 GMT

so i'm kind of following a more rsc-like model where each distributed piece is responsible for hydrating what it needs. so outputs can be cached, sort of like old school cached partials in php but between all users. avoids expensive recompute that's specifically for concrete uis (like skircles)

2026-02-03 03:30:32 GMT

and then maybe if some of these get popular across different "browsers" (or really hobbyists who play with new styles of interactions and stuff), they become de facto standards. until someday they get unsupported and stuff breaks but then you can patch it. etc

2026-02-03 03:29:48 GMT

maybe someone else then wants it in svelte, or react, or web components, or whatever, so there can be competition between implementations. whoever implements the same component lexicon with best ux. maybe ai could try too

2026-02-03 03:19:31 GMT

anyway that's rambling but maybe you have some ideas for these things, i'll try to get basics working but i'm a bit lost

2026-02-03 03:18:52 GMT

so maybe more complex interactions are also possible, like drag and drop (i have that working), main/detail, lazy stuff, probably forms and stuff. but then mutation/invalidation is pain and serious routing, if needed, may be a pain too. and choosing primitives seems high stakes if people start using

2026-02-03 03:16:46 GMT

if you can have infinite scrolling, it probably means you can do other stuff. i have <Tabs> taking an array of route matches so it can "catch" at:// <Link> clicks on "posts" and show the nsid associated with the route match. like your own Post component or whatever.

2026-02-03 03:15:32 GMT

for example i really like my <List> that just takes an array of at-uris for items, an nsid for the component per row. i'm not sure if i'm keeping that but its loadMore prop is just another <List> with next cursor as a prop. so you can have infinite scrolling while keeping everything declarative

2026-02-03 03:11:41 GMT

primitives are a big question for me. i think it's almost a unique space where they should be quite high level but still very generic. and not require any explicit code. adaptivecards.io and docs.slack.dev/block-kit/. seems in a related space. (thanks @[email protected] for the tip)

2026-02-03 03:07:42 GMT

for caching a neat thing you can do (as i saw in Next.js) is to always call components with unresolved nested components, sort of opaque slots, which makes the output cacheable independently from the opaque inputs. lets you cache even things that wrap other things

2026-02-03 03:06:26 GMT

so this gives you ability to fix things if some nested endpoint died until somebody fixes their dependency. also lets you switch out to your own fork ("i want this different profile tab") but with understanding that it's a bit fragile. seems important though to be able to do that

2026-02-03 03:05:15 GMT

components refer to each other solely through nsids so actual binding to endpoint happens at arbitrary times. maybe a starting point is to use the npm model — components explicitly bind their dependencies to endpoints, but resolution happens in the root, can take into account lockfile and overrides

2026-02-03 03:03:57 GMT

so the code sketch is just a recursive resolver that says "if this server-browser implements this lexicon, just render that, otherwise call xrpc and recurse from the response". plus optimizations based on caching some of the calls if they haven't expired globally

2026-02-03 02:51:57 GMT

the server side is also annoying because we either have to let the host be a permission owner and build a parallel system (seems bad) or just rely on oauth but then you have to sign in "into" any origin widget. which on the other hand maybe makes sense as a trust model? but annoying to fill in

2026-02-03 02:49:16 GMT

mutations are kind of annoying as usual, you'd have to somehow deal with the cache between components that don't know each other and keep the behavior sensible (e.g. don't update everything all the time, but also a single thing is sometimes not what you want). mirroring +1 like counts is an example

2026-02-03 02:47:42 GMT

you'd think performance is a big problem but if you make it yieldy like react, maybe it's okay? the server can memoize globally, at uris are good keys, seems like it should be possible to have mechanism like cacheTag in Next.js hooked up to the firehose? even for backlinks? seems cacheable

2026-02-03 02:46:03 GMT

this is probably still too limiting for final bit of polish. maybe this is why it can't be a final space. so maybe it's a space for something more simplified, like "less than a product". something like skircle is a good example but maybe there could be more experimentation with those things

2026-02-03 02:44:45 GMT

one difficulty is that you probably don't want to mix different third-parties' client-side behaviors, or at least i don't know how to do it safely. maybe there's some way to narrow it down. but maybe the host's built-in collection could be very expressive but entirely declarative. like good sdui

2026-02-03 02:42:59 GMT

individual atproto uis are already remixing data from different apps. so the concept of an "app" blends — each product is a prism over the shared ecosystem. and if nothing except authorship is firmly gluing different pieces, could an application be glued together from different authors' pieces?

2026-02-03 02:38:10 GMT

i want to put components on atproto because i want to figure out why this concept doesn't work

2026-02-03 02:35:21 GMT

i basically have a thing that would really benefit from server-side request-response sandboxes callable via http, but i really don't want to run those sandboxes myself or think about how to rate limit them or isolate them or keep them warm and so on

2026-02-03 01:15:41 GMT

basically this docs.val.town/openapi but driven by atproto records would be nice
Val Town API Reference

2026-02-03 01:07:56 GMT

i mean ideally pds would be source of truth for atproto-managed vals and i could just create vals and files via pds

2026-02-03 00:50:42 GMT

now we're talking (literally)
https://morel.us-east.host.bsky.network/xrpc/com.atproto.sync.getBlob?did=did:plc:fpruhuo22xkm5o7ttr2ktxdo&cid=bafkreidrpadvi3v5ebzwlxgvcpzcyshmpyn7hbs4fekxa5pbfay6uq33l4

2026-02-03 00:23:53 GMT

back to basics
https://morel.us-east.host.bsky.network/xrpc/com.atproto.sync.getBlob?did=did:plc:fpruhuo22xkm5o7ttr2ktxdo&cid=bafkreic3mcev2kp5fmcmo5lx3ufsq5z2h6rujtks35zrcoqbl4gadiq2ly

2026-02-03 00:20:01 GMT

wishing for something like @[email protected] but on atproto

2026-02-03 00:00:15 GMT

@macwright.com quick q. how "cool" is it to create new vals programmatically? i'm considering integrating with it for something i'm building but not sure it's the intended use case. eg are vals gonna get rate limited, how hard, etc

2026-02-02 23:44:13 GMT

build everything twice seems like it might be best of both worlds: maximilalist exploration unconstrained by limits of my ability or patience, then minimalist honing where known wrong things aren't allowed to creep in. maybe this works

2026-02-02 23:43:00 GMT

to explain more about the burnout
it's because i can't both macromanage and micromanage. so if i let claude do most of the work, i can't make targeted small changes. since too many small wrong things have crept in already that i'm not familiar with
and if it's stuck, i'm stuck with uncanny system

2026-02-02 23:38:30 GMT

one approach i'm trying now is to build everything twice
first build is maximalist. let the llm make more technical decisions, expand scope to try different things, get a feel for what works or doesn't
second build is minimalist. keep solid parts, everything else from scratch. review every line

2026-02-02 23:25:17 GMT

lmk if this is helpful, can expand on any points (or ask experts)

2026-02-02 23:19:05 GMT

the longer term plan is to make it a legally independent org, kind of like ICANN. not sure what the progress on this has been: docs.bsky.app/blog/plc-dir...
if that happens, hopefully there isn't really a good reason for fragmentation later since technically it is not sophisticated

2026-02-02 23:16:31 GMT

so there is no technical difficulty in anyone spinning up a successor into which every existing user can log into and continue to stay in control of their identity. the difficulty would be in getting everyone to agree which successor is "the" one. which is a good reason to make current one neutral

2026-02-02 23:10:38 GMT

basically, it's centralized (and that has downsides, see updates.microcosm.blue/3lz7nwvh4zc2u) but it's also pretty far from most centralized registries (like npm for example) because:
- it's entirely open source
- it holds no private data at all
- every update is recursively auditable

2026-02-02 23:09:17 GMT

@chadtmiller.com looks like teal-relay-production.up.railway.app is down, is there any other version i could link to? want to keep it up for the article somewhere
teal-relay-production.up.railway.app

2026-02-02 14:39:41 GMT

i need to figure out some kind of mvp for inlay. got distracted by looking at Adaptive Cards, thinking about lexicon embeds, and i just don't have a concrete product direction at this point

2026-01-31 17:17:48 GMT

maybe it has to work this way though. i just hate the idea of a permission manager on top of a permission manager

2026-01-31 15:19:36 GMT

how useful this can be probably depends a lot on the composition primitives. i’m not convinced you can make whole apps of this, so it might need a less ambitious paradigm at first (cards?) but i’m also not a designer so this is hard mode too.

2026-01-31 15:18:00 GMT

one thing i struggle with is that i’m really not a product person. so like… can it ever be useful? idk.
need to find energy to finish and release it cause it’s easy to fall into a loop of discouragement. i’ll play video games now
#nevent1q…nwzy

2026-01-31 10:34:27 GMT

if i can reply with links of my own i offer these two:
1. nostalgebraist.tumblr.com/post/7857667...
2. transformer-circuits.pub/2025/attribu...
i think together they give a more precise framing than “waah machine thinks” or “wahh machine doesn’t think”

2026-01-31 10:11:01 GMT

i personally find it useful to think of LLM as being two layers
the upper layer is like a character in a play. we can talk about that character’s motivations etc while conceding it has no first-person experience
the lower layer is like a hyperdimensional spaceship in the cosmos of language

2026-01-31 09:57:13 GMT

also “comes across as …” does not imply that the genuine interest is actually “there”. i’m talking about whether it is believable or not based on the text. if you went to theatre where all actors are p-zombies, you could still discuss whether you were moved by the play. imo it’s similar

2026-01-31 01:18:06 GMT

this is another reason why these are “events” — when designed well, looking at the log would tell you what actually happened. it’s not just some callback you extracted as an optimization. in a sense it’s the “output” of this effect — a stream of events with info attached to them

2026-01-31 01:16:21 GMT

my mnemonic for this is “if i saw this event in console log with its arguments, would it make sense to me as a user”. eg “visited a page with url” does make sense as conceptual event that i can map to what i was doing in the app. whereas “mounted” is not.

2026-01-31 01:15:27 GMT

whereas if you just think in terms of “i don’t want this to re-run” then maybe you miss the nuance about what *should* cause it to re-run. and forget to make those things arguments. i think ideally docs would teach this process. intentionally designing what is reactive and what is not

2026-01-31 01:13:59 GMT

it’s a very similar process to deciding “what goes into action object” in redux. you have to decide what constitutes an event. here it’s similar like with onVisit() example — maybe url becomes a part of it (= reactive to url) but shopping cart item is not. so it’s onVisit(url) then. it’s intentional

2026-01-31 01:11:13 GMT

so it’s not that either approach is wrong but i think it always requires this negotiation. you start with your perspective (“re-running this seems wrong”) then you shift to effect’s perspective (“this piece of code is my output, it doesn’t belong here”), then you verify if that fixed the problem

2026-01-31 01:09:35 GMT

so i think in practice it’s a bit of a negotiation:
1. you start with “i don’t want this to re-run too often”
2. then you step back and think “okay but what is the exact boundary between the information that’s flows into this effect and the information that flows out of it”
3. then you cut it

2026-01-30 19:33:02 GMT

i generally like claude’s character but one thing that irks me is the return question prompts at the end (“was there something in particular that made you think of this?” and the like)
it feels manipulative and rarely comes across as genuine interest. i guess normal people rely on reciprocity?

2026-01-30 18:44:00 GMT

so the only place where you can break reactivity becomes the place where it has the risk of looping. rather than something upstream.

2026-01-30 18:38:21 GMT

the usage section seems more concrete so it’s mostly reference part i’m picking on

2026-01-30 18:30:27 GMT

like
> Effect Events are functions you can call inside Effects, such as useEffect.
i can call any functions there! this doesn’t tell me anything.
what we need to convey is that this lets you move code that you don’t want to be reactive out of the effect. and that conceptually it’s like events

2026-01-29 17:51:55 GMT

i get why some people crosspost to multiple apps but it's so weird when you never open the app or engage with the replies here it's like a shitty hologram or something

2026-01-29 17:32:43 GMT

i.e. i'd expect to not have two separate loading states. just click Next, it does the resolution, then redirect. any reason why not that?

2026-01-29 16:56:12 GMT

wait social-app can’t resolve handles by default? i completely forgot there’s that dropdown.
is there a technical reason it doesn’t?
#nevent1q…0mt9

2026-01-29 13:27:03 GMT

i'll send in a late proposal using the contact form