Imagine people believing morality and acting on it?!
I literally did, for a bunch of my projects and the ones of clients. A friend even did it for a pretty big brand that had a juicy Vercel bill. Burn in hell Guillermo
Vercel UI SDK is a "headless" UI tooklit. "Headless UI" is packaging of behavior that has to be implemented in javascript to get properly working widgets.
For instance, to implement a menu you have to support things like keyboard navigation and auto-closing when the user clicks elsewhere.
Gettings these sort of behaviors right across all browsers is oftentimes _hard_, and testing them properly is very time consuming. That's why it's useful to have it built and tested by a large company.
Traditionally, these behaviors came built-in with your "UI Widget Library" of choice (e.g., https://ant.design/). However, widget libraries bring in their own style and subtle opinions. When you are aligned with those everything is great, but when you want to deviate visually or behaviorally then you have a hard time.
In contrast, "headless UI" packages these behaviors (and only the behaviors) as little snippets that you "plug in" to your own widgets/components. Since how these behaviors get to be "plugged in" to components and how they can interact between them may be dictated by the UI framework/library (e.g., react, astro, solid) the headless ui kits explicitly call those that they support.
"Built to be written by agents"? To me that would mean to drop the framework altogether: they've always just been an abstraction to bridge knowledge gaps in bigger teams and enforce coding patterns. But now that's just the job of the agents, and instead you can prompt it to set up a proper server in any language you want.
You could say that about some libraries, but LLMs haven't made reactive frameworks obsolete; on the contrary, they're very effective at using them, and they write better, more maintainable, and more consistent code with them than when they try to hand-write JS that renders to the DOM. Anything that can "bridge knowledge gaps in bigger teams and enforce coding patterns" can also help write code with agents!
If anything, I think attention limits, token costs, and declining performance as size/complexity increase means good abstractions are more necessary than ever.
I'm working on something right now it's called ReactiveScript which takes Solid's constraints and makes them in the compiled language. Its still WIP but early results are promising. It can do better than vanillaJS because async bugs are compiler error by construction etc. It's a bit like the Rust mentality. If the agent can't write bad code if it won't compile.
I think we will see more of this. Frameworks have been "languages" for years. Rich Harris of Svelte saw that. This is exactly the remaining gap right now. Peeling away the layers is also peeling away the guard rails. You can add those back with rigor of testing. But huge benefits to just encoding our learnings in the language itself.
You've always been able to early return in Solid it just was never going to do what you expected because components run once. That's not something to fix. A language can look at `if` and say that's a `<Show>` component, but effectively its wrapping the choice in the templating(reactive expression). It doesn't really matter because those templates run once too so nesting is fine. But ultimately supporting it is supporting sugar not much else.
A lot of my react components start out with the equivalent of
if (state==error) return <p>error</p>;
if (state==loading) return <p>loading</p>;
if (!connection) return <p>offline</p>;
if (admin) return <Redirect/>;
doing that with <Show /> (and passing the function so TypeScript still works) means the conditions take 20 lines instead of 4, and the meat of my component is indented an extra 8 levels.
Makes sense, Signal dependency graphs can also be more easily debugged/visualuzed with a compiler in a way that does not require manual labeling. I did this with a toy compiler I built that's just a subset of Typescript with a new reactive variable operator (which personally i find to be the most sensible approach for a frontend DSL). Not sure what you mean by guards rails though, the Rust compile check mentality is exactly the type of pampering that the webdev community likes.
I honestly don't remember what drove me (and apparently a lot of the frontend JS community) to place my bets on Svelte over Solid, years ago now. It probably had something to do with Svelte feeling (and at the time, being) much simpler to develop in, looking on the surface like simple HTML and CSS with some JavaScript sprinkled in, and believing strongly in its magic compiler.
Honestly, I was probably just so tired of React that it felt refreshing to develop in something so un-React-like, and it ergonomically felt better at the time than writing something similar to React via Solid, even if the latter was still holding its own in performance on paper. If you've spent years learning French then it might feel more refreshing to start learning Japanese than Italian.
It turns out Solid had a lot of it right all along. And after using Svelte for a while, something starting feeling... weird. For all its complexity, something I always appreciated about React was that I was ultimately just writing JavaScript, and with Svelte it felt like I was writing in something only made to resemble JavaScript.
I still really appreciate Svelte, but I'm wondering if this would be a good time to see if Solid will feel more "natural" to me, having worked with JavaScript all these years. Curious if anyone can confirm if that would be the case.
Now might also be a good time to tinker with it myself before the coding models are fully up to date on 2.0 and I turn to laziness (/efficiency) and have them handle the rest.
I used Svelte extensively since v3 but ended up switching to Solid this year. I just want to be able to write TS/TSX without needing any extra tooling around it.
Solid is just JSX which is stock typescript tooling.
* Does not need any unique editor plugin like Svelte and Vue to provide a language server.
* Worked with Tsgo day 1.
* Works with oxfmt by default day 1.
* Works somewhat with oxlint out of the box day 1, eslint plugin is fully supported.
Svelte has a much more complicated build system and customised plugins that need regular upkeep, for basic usage it might just look like a vite plugin line and the eslint/prettier config that gets generated as part of project init but as your app grows and you maintain it longer term you absolutely start feeling the deficiencies and weight of all the svelte tooling.
Solid has a compiler and an eslint plugin, but otherwise leverages the standard typescript tooling, it's so much faster. Ryan's looking at reactive script now but it was an extremely good decision to not take on the tooling maintenance of Svelte and Vue.
It does, but it's not needed for static analysis at all. From an IDE's perspective, SolidJS is just completely normal JSX expressions, which it can usually already handle.
I also remember caring about frameworks, and having long debates on HN about what was better. Haven't cared or done that in quite awhile now. It's be like debating low level assembly instructions. We just no longer work at that level.
I was in same position, but I picked Svelte because I really liked the older syntax. `$: derived` values, everything reactive, etc. But post Svelte 5, even though I get the why - it's so similar to other libs like React and Solid that Solid makes more sense for me now.
Remix originally pitched itself as solving the 'middle' layer between frontend and backend. Closing the gap. It never quite managed to do so imo.
Solid's solution here is beautiful. The server RPC and 'live' and 'broadcast' are seamless, and feel much more natural to use than liveview or htmx/datastar imo.
It's terse but I can make sense of this. I read it as broadcast() wrapping a single live() somehow, because invoking live() per a connection on the server would lead to viewers (clients? callers?) potentially seeing different streams.
Remix (and React router, and the folks behind it) pitch a different thing each week, and they never manage to do it because they change their mind every Tuesday.
What's amusing and/or interesting is that the stuff under "Built to Be Written by Agents" also would make it easier to write by hand, I imagine. It's just better debug diagnostics; nothing really to do with agentic development specifically.
Maybe that's just marketing, but it's really intriguing how human best practices are also agent best practices; how, maybe, we've reached a point where even devs aren't recognizing agent best practices as human best practices anymore; and how suddenly best practices are being prioritized in a way they often weren't - humans could/would/were expected to suck it up and deal with poor devex, but agents simply can't. A strange sort of victory for us folks who cared about it.
The way Rust compile times can sneak up on you as your project grows is not to be underestimated. More so if you're running multiple agents in parallel.
But frankly I don't mind it as much with agents as I did when handwriting the code. It's on the agent to endure the slower feedback loop.
waiting for the cargo lock is something else: cargo was not designed for multiple simultaneous entities developing in parallel
my take is, in the current state of the ecosystem, you should use https://github.com/kunobi-ninja/kache and make agente work on separate worktrees,each with their own target directory
usually separate target dirs means multi-gigabyte artifacts for each worktrees (and waiting for the same code to compile again). but not with kache, it builds only once and reduplicate files (with reflinks if your filesystem supports it)
there's also some projects for live reloading rust, and some specific tips about faster builds during iterative development (the most relevant being, use the mold linker)
A friend of mine who works a lot with AI commented that working with AI was making him develop like a grownup for the first time. Turns out that all the best practices really do carry over, but the consequence of not doing it is greater with agents.
AI has forced me to write out more planning documents. Not waterfall strategic planning, but tactical planning such as describing the desired behavior of a script before I write it, or pre-registering a data analysis and my expected findings in writing before I start querying data -- that goes in a PLAN.md within whatever folder I'm working on at the moment.
I now keep a systematic todo list that I call TASKS.md, which groups tasks into topical sections and every task has an ID, such as MD3 or EV7.
I also keep an append-only-ish journal of results, findings, unfinished thoughts, rejected ideas, etc.
All of that goes right into my project Git repo. It works great for both AI agents and humans.
But perhaps more interesting than my new workflows, is that I actually learn things from the AI. The idea to start pre-registering all my little analyses, not just the big tasks, was a Claude-ism that I've since adopted even when I'm not using AI.
I do TODO.md instead of TASKS.md but what's the benefit of giving each task an ID? Just easier for you to refer to a specific task? I usually just paste the whole line if I need to refer to it, but given it a short ID might not be a bad idea.
Yeah, the main benefit is being able to refer to specific items rather than ambiguously referring to patterns that might be misinterpreted by the model.
Yes, that. And -- in keeping with the theme -- it's just as useful for me, the human, as it is for the model. I can even cross-link them to Jira items, so I can say things like "task EV5 corresponds to Jira subtask DS-7491 within story DS-7389".
Also this is in the context of data science, so I often have a big and ever-growing list of secondary analyses I could run, and each one ends up with a small pile of source code. This actually lets me organize my code around the IDs, so I can have a directory like `analysis/EV7/` with its own little PLAN.md and README and some .sql and .py files and a .ipynb to pull together the results (and/or a small AI-generated data explorer app). And then later if I need to refer to those results I can write a comment like "parameter derived from EV7 results" or whatever.
git logs are a bit of a pain to search through and also perhaps not the place to insert long instructions, I do remember looking at some repo and just browsing the list made me quickly find what was intended during development.
It's really "fun" how people suddenly started writing short and concise tutorials on how to use a tool or a library without too much yapping, and somehow instead of being at the beginning of the docs, it's buried deep in "skill.md" file, not intended to be seen by humans.
In my experience the agents actually read the AGENTS.md. I used to put info in the README.md but only noticed uptake when I put it in AGENTS.md instead.
On the other hand, Nextjs has been adding debug info that is feasible for agents to parse, but are basically inscrutable to human developers with limited context widows.
Have you looked at Docker's home page recently? The title is now "Secure Sandboxes for AI Agents". There is some insanity going around, rebranding basic tools as "for agents". Docker is just secure sandboxes for everyone, from that tagline you'd think they were somehow specifically made for agents.
Sure, it can be marketing, but I think it's more that it has become evident that the best way to get agents to write code you can trust, at a scale that actually improves productivity, usually means adopting and enforcing best practices at a scale that the industry silently really wasn't doing at all.
I've spent the last few years banging on a drum about teams installing linters, static analyzers, and similar in Laravel teams. I get nods of agreement from seniors but little willpower from managers, who just want to see the number of commits line go up.
Surprise surprise, now that I am in charge of a project and have enforced these standards, the team has done incredibly well with even just partial AI adoption in their work - because the guard rails are there and agents don't get tired of hitting them.
The async graph is VERY cool. It does a great job of encapsulating async's nature to cause "colored" functions by using the existing signal graph (which admittedly is its own color; but virtually every UI framework has similar coloring so at least Solid's cutting a color/making it composable).
Contrast that with React, where hooks are colored functions. You thought that hooks were just functions? Nope, if you have a hook, it MUST be called in a hook/component... exactly like async. Did you want to load this TTS player conditionally? Hahah, you can't. Have fun allocating memory for every TTS provider your app supports, even if the user uses only 1 player. https://news.ycombinator.com/item?id=45257413
"Thanks to async in the graph we can detect waterfalls, poorly constructed effect loops, poorly scaling graph shapes like wide graph fanouts and fan-ins." Incredibly cool. Apparently Tanstack Query has a waterfall detector https://github.com/bamlab/tanstack-query-detect-waterfall so the other frameworks have something similar, but it won't work with their state graphs.
That does not work because `loadTTS` is actually a hook, so its `useLoadTTS`, and hooks must be top level. I encourage you to look at the pastebin in my link, repeated here https://pastebin.com/sjc3vXTd
So, I must have
let provider = useGetUserPreference()
let a = useLoadTTS_A()
let b = useLoadTTS_B()
let c = useLoadTTS_C()
useEffect(() => {
if (provider=="a") a()
if (provider=="b") b()
if (provider=="c") c()
})
Oh hey, what's that? I have to allocate memory for b and c even though only a is used? THANKS REACT.
It sounds like `useLoadTTS` shouldn't have been a hook then? You don't have to make everything a hook just because they exist. Hooks are just one tool in the toolbox. There's no shame in a useState or useEffect.
> "Thanks to async in the graph we can detect waterfalls, poorly constructed effect loops, poorly scaling graph shapes like wide graph fanouts and fan-ins."
That needs to emphasized more. Pretty sure React's Suspense suffers from waterfalls if memory serves.
Still waiting for Vue 3.6 Vapor to be released which is supposed to be more competitive with these frameworks like Svelte and Solid in performance. Vue 3.5 came out in Sept 2024 and I've ported a lot of code off Vue since then.
I see something like ”const user = createMemo(() => fetchUser(props.id));” or “use server” and I’m instantly reminded of why I abandoned JS frameworks (not to mention anything touching JS on the server).
I much prefer Solid over React, but at least the idea of a compiler makes so much more sense instead of manually maintaining memoization.
Congrats to Ryan and the team. I never got deep enough into front-end to understand the nuance of these things but I still occasionally tuned into his Friday streams just to listen. You can tell he cares about this subject deeply and I enjoy listening to passionate people talk about their craft.
As a frontend developer it's a solid (heh) paradigm shift.
Turns out the secret to fine-grained reactivity all this time was just a tree structure describing the dependencies.
I'm using signals in Angular and while they don't cover every use case cleanly, they're a huge upgrade compared to RxJS Observables - particularly due to how simple and debuggable they are in comparison.
Tangential, but since the thread is all DOM: I've been using Solid 2's universal renderer for native watchOS UIs, and just put the renderer and host up as an MIT repo: https://github.com/esensible/solid-watch
The bundle (Solid JSX compiled with the new babel plugin) runs in QuickJS-ng on the watch; the renderer emits node mutations over a small host interface; a Swift host lays them out with Yoga and draws with SwiftUI. The same bundle runs in a browser harness for development. The structure is borrowed from React Native's Fabric: three trees, batched commits, one schema that generates the prop code for both sides. A dozen node types, React Native style names, on purpose.
For context, it's the display layer of a larger personal project (not open source at this point): application state lives in a small expression language with a Rust evaluator, running on the phone or on an ESP32 box, with the state, events and view described by JSON Schemas and a schema-derived wire codec. The watch and an e-ink display are synced views of that state. Bundles and firmware are served and updated over BLE, and the phone app has a sign-in-with-ChatGPT authoring mode that writes the Solid UI and the expression logic against those schemas, checks them on the device, and packs the bundle locally on the phone, no server. Solid's universal renderer is what made the watch part feasible: the UI author writes ordinary JSX and the same bundle runs on the wrist and in a browser tab.
Rough edges in the public piece: you build the QuickJS xcframework yourself, and getting a bundle onto a real watch still means an Xcode build. Examples built with plain npm and the browser harness are in the repo if you want to poke at it. Moving from the RCs to 2.0.0, the only breaking change I hit was <Show> compiling to a ternary, which only reordered mutations inside a commit.
This comment was flagged presumably as AI slop, but it was useful to me to discover that solid now has a universal renderer. For a long time that has been the differentiator in favour of react.
Solid has had a universal renderer for a long time, and quite easy to swap out. For example, see https://lightning-js.github.io/solid/#/ (WebGL renderer for Smart TVs)
AFAIK React has never had a properly defined renderer, and it was a pain to swap out
Now we just need Qwik 2.0 to get released for their async resumable framework.
I think with the advent of AI it doesn't matter so much about the DX and your main focus should be on better UX (the best lighthouse metrics) though I don't think their DX is bad either.
Meanwhile people using Blazor shipping 50mb of .NET assemblies (maybe it's become better in newer releases but when it appeared that made me nope-out quite quickly).
I really like the ideas and concepts (one graph integrating async and reactivity) and also been a fan for some while (watching (at least in parts) Ryans YT streams, having used Solid 1.0 for a smaller project). But I have some mixed feelings knowing that the majority if not all code was written by AI. I have no doubt that every line was reviewed carefully. But this is a very complex code base. And I'm old enough to know that reading is miles away from writing when it comes to understanding. So, I'm sitting here wanting to choose Solid 2.0 for every new project but on the other hand having those nagging doubts whether that project is really sustainable. By the way, those are the same doubts I have for all newly created projects and I usually don't spent a second considering them, but this is a very special case because of Ryan and the team and because of Solid 2.0 being IMO such a significant step in simplifying frontend dev. I guess I need to see a therapist helping me out of my personal AI crisis ... I'm still writing all my code myself and are not left behind like the other dozends of us ;-).
Ryan Carniato is to Solid as rhickey is to Clojure as evancz is to Elm.
They all convinced me to use their respective languages by sharing all the thought they put into them, especially to address problems in the alternative, more popular options.
ishritmadaan | 23 hours ago
[OP] pier25 | 23 hours ago
maxloh | 23 hours ago
It just feels like the right way React should be.
dbbk | 23 hours ago
robertlagrant | 23 hours ago
squidsoup | 22 hours ago
latchkey | 21 hours ago
dbbk | 21 hours ago
skrebbel | 12 hours ago
dbbk | 6 hours ago
pwmglenn | 22 hours ago
Vercel's UI SDK just launched with Solid support.
Theres also Kobalte, Ark UI, Park UI, Solid UI, Shadcn Solid, Corvu, Material Design Solid, and more.
salah7252 | 22 hours ago
giveaccountpls | 21 hours ago
I'm being facetious, but what would you expect?
azangru | 21 hours ago
gr__or | 19 hours ago
I literally did, for a bunch of my projects and the ones of clients. A friend even did it for a pretty big brand that had a juicy Vercel bill. Burn in hell Guillermo
tommica | 12 hours ago
That is a bit of an over-reaction.
mfru | 11 hours ago
mfru | 11 hours ago
elxr | 17 hours ago
Appreciate the the other examples though.
kilburn | 11 hours ago
For instance, to implement a menu you have to support things like keyboard navigation and auto-closing when the user clicks elsewhere.
Gettings these sort of behaviors right across all browsers is oftentimes _hard_, and testing them properly is very time consuming. That's why it's useful to have it built and tested by a large company.
Traditionally, these behaviors came built-in with your "UI Widget Library" of choice (e.g., https://ant.design/). However, widget libraries bring in their own style and subtle opinions. When you are aligned with those everything is great, but when you want to deviate visually or behaviorally then you have a hard time.
In contrast, "headless UI" packages these behaviors (and only the behaviors) as little snippets that you "plug in" to your own widgets/components. Since how these behaviors get to be "plugged in" to components and how they can interact between them may be dictated by the UI framework/library (e.g., react, astro, solid) the headless ui kits explicitly call those that they support.
For Vercel UI SDK specifically, you can check the list of behaviors they implement here https://ui-sdk.dev/docs/core/behaviors
kalualualeiamba | 19 hours ago
ale | 23 hours ago
aurareturn | 23 hours ago
So if a framework is made so that coding agents can use it well, why is it a negative?
I’m not going to be writing SolidJS by hand.
conartist6 | 16 hours ago
croes | 23 hours ago
rafram | 23 hours ago
squidsoup | 22 hours ago
jaapz | 21 hours ago
kube-system | 22 hours ago
Then ask Claude to write a SaaS landing page for you in assembly.
Then compare the results.
wpietri | 22 hours ago
elxr | 17 hours ago
I'll gladly sacrifice 20%-30% of features of one thing over another if it lets me use that much fewer tokens.
ryansolid | 21 hours ago
I think we will see more of this. Frameworks have been "languages" for years. Rich Harris of Svelte saw that. This is exactly the remaining gap right now. Peeling away the layers is also peeling away the guard rails. You can add those back with rigor of testing. But huge benefits to just encoding our learnings in the language itself.
nvme0n1p1 | 20 hours ago
thomastill | 20 hours ago
ryansolid | 19 hours ago
nvme0n1p1 | 2 hours ago
Yeah that's what I mean.
A lot of my react components start out with the equivalent of
doing that with <Show /> (and passing the function so TypeScript still works) means the conditions take 20 lines instead of 4, and the meat of my component is indented an extra 8 levels.ale | 6 hours ago
agos | 9 hours ago
_nothing | 23 hours ago
Honestly, I was probably just so tired of React that it felt refreshing to develop in something so un-React-like, and it ergonomically felt better at the time than writing something similar to React via Solid, even if the latter was still holding its own in performance on paper. If you've spent years learning French then it might feel more refreshing to start learning Japanese than Italian.
It turns out Solid had a lot of it right all along. And after using Svelte for a while, something starting feeling... weird. For all its complexity, something I always appreciated about React was that I was ultimately just writing JavaScript, and with Svelte it felt like I was writing in something only made to resemble JavaScript.
I still really appreciate Svelte, but I'm wondering if this would be a good time to see if Solid will feel more "natural" to me, having worked with JavaScript all these years. Curious if anyone can confirm if that would be the case.
Now might also be a good time to tinker with it myself before the coding models are fully up to date on 2.0 and I turn to laziness (/efficiency) and have them handle the rest.
[OP] pier25 | 22 hours ago
tancop | 22 hours ago
[OP] pier25 | 22 hours ago
DimmieMan | 20 hours ago
* Does not need any unique editor plugin like Svelte and Vue to provide a language server.
* Worked with Tsgo day 1.
* Works with oxfmt by default day 1.
* Works somewhat with oxlint out of the box day 1, eslint plugin is fully supported.
Svelte has a much more complicated build system and customised plugins that need regular upkeep, for basic usage it might just look like a vite plugin line and the eslint/prettier config that gets generated as part of project init but as your app grows and you maintain it longer term you absolutely start feeling the deficiencies and weight of all the svelte tooling.
Solid has a compiler and an eslint plugin, but otherwise leverages the standard typescript tooling, it's so much faster. Ryan's looking at reactive script now but it was an extremely good decision to not take on the tooling maintenance of Svelte and Vue.
christophilus | 19 hours ago
[OP] pier25 | 15 hours ago
MrJohz | 14 hours ago
bottlepalm | 22 hours ago
gedy | 19 hours ago
pwmglenn | 22 hours ago
Solid's solution here is beautiful. The server RPC and 'live' and 'broadcast' are seamless, and feel much more natural to use than liveview or htmx/datastar imo.
ricardobeat | 20 hours ago
> Declares a live server function whose answer is the same for every viewer: on the client exactly live(fn) — the sharing is the server's.
> See Share one live answer across viewers for what is shared, what runs per caller, and the compile-time capture rule.
> live() runs one producer per connection, which is right when the answer can depend on who is asking.
hmry | 14 hours ago
skew-aberration | 13 hours ago
weego | 7 hours ago
Broadcast is one result to many Live is many results to many
conartist6 | 9 hours ago
Nearly horfed right on my laptop. I won't be using that slop fest.
0xblinq | 19 hours ago
wk_end | 22 hours ago
Maybe that's just marketing, but it's really intriguing how human best practices are also agent best practices; how, maybe, we've reached a point where even devs aren't recognizing agent best practices as human best practices anymore; and how suddenly best practices are being prioritized in a way they often weren't - humans could/would/were expected to suck it up and deal with poor devex, but agents simply can't. A strange sort of victory for us folks who cared about it.
novacrazy | 21 hours ago
snordgren | 21 hours ago
Bolwin | 21 hours ago
[OP] pier25 | 15 hours ago
melodyogonna | 9 hours ago
Citation is needed
mihaelm | 19 hours ago
But frankly I don't mind it as much with agents as I did when handwriting the code. It's on the agent to endure the slower feedback loop.
nextaccountic | 18 hours ago
my take is, in the current state of the ecosystem, you should use https://github.com/kunobi-ninja/kache and make agente work on separate worktrees,each with their own target directory
usually separate target dirs means multi-gigabyte artifacts for each worktrees (and waiting for the same code to compile again). but not with kache, it builds only once and reduplicate files (with reflinks if your filesystem supports it)
there's also some projects for live reloading rust, and some specific tips about faster builds during iterative development (the most relevant being, use the mold linker)
supermatt | 9 hours ago
obeavs | 15 hours ago
phplovesong | 10 hours ago
lemming | 21 hours ago
gwerbin | 15 hours ago
AI has forced me to write out more planning documents. Not waterfall strategic planning, but tactical planning such as describing the desired behavior of a script before I write it, or pre-registering a data analysis and my expected findings in writing before I start querying data -- that goes in a PLAN.md within whatever folder I'm working on at the moment.
I now keep a systematic todo list that I call TASKS.md, which groups tasks into topical sections and every task has an ID, such as MD3 or EV7.
I also keep an append-only-ish journal of results, findings, unfinished thoughts, rejected ideas, etc.
All of that goes right into my project Git repo. It works great for both AI agents and humans.
But perhaps more interesting than my new workflows, is that I actually learn things from the AI. The idea to start pre-registering all my little analyses, not just the big tasks, was a Claude-ism that I've since adopted even when I'm not using AI.
hdjrudni | 9 hours ago
LoganDark | 7 hours ago
gwerbin | 5 hours ago
Also this is in the context of data science, so I often have a big and ever-growing list of secondary analyses I could run, and each one ends up with a small pile of source code. This actually lets me organize my code around the IDs, so I can have a directory like `analysis/EV7/` with its own little PLAN.md and README and some .sql and .py files and a .ipynb to pull together the results (and/or a small AI-generated data explorer app). And then later if I need to refer to those results I can write a comment like "parameter derived from EV7 results" or whatever.
whizzter | 4 hours ago
victorbjorklund | 8 hours ago
deniska | 20 hours ago
nullpoint420 | 2 hours ago
Vinnl | 19 hours ago
phailhaus | 18 hours ago
Shorn | 14 hours ago
Secure? o_O
TheCapeGreek | 6 hours ago
I've spent the last few years banging on a drum about teams installing linters, static analyzers, and similar in Laravel teams. I get nods of agreement from seniors but little willpower from managers, who just want to see the number of commits line go up.
Surprise surprise, now that I am in charge of a project and have enforced these standards, the team has done incredibly well with even just partial AI adoption in their work - because the guard rails are there and agents don't get tired of hitting them.
otherflavors | 21 hours ago
prajaybasu | 21 hours ago
ryansolid | 19 hours ago
AlexErrant | 20 hours ago
Contrast that with React, where hooks are colored functions. You thought that hooks were just functions? Nope, if you have a hook, it MUST be called in a hook/component... exactly like async. Did you want to load this TTS player conditionally? Hahah, you can't. Have fun allocating memory for every TTS provider your app supports, even if the user uses only 1 player. https://news.ycombinator.com/item?id=45257413
"Thanks to async in the graph we can detect waterfalls, poorly constructed effect loops, poorly scaling graph shapes like wide graph fanouts and fan-ins." Incredibly cool. Apparently Tanstack Query has a waterfall detector https://github.com/bamlab/tanstack-query-detect-waterfall so the other frameworks have something similar, but it won't work with their state graphs.
nvme0n1p1 | 20 hours ago
Um, you can? Just change this:
to this:AlexErrant | 17 hours ago
That does not work because `loadTTS` is actually a hook, so its `useLoadTTS`, and hooks must be top level. I encourage you to look at the pastebin in my link, repeated here https://pastebin.com/sjc3vXTd
So, I must have
Oh hey, what's that? I have to allocate memory for b and c even though only a is used? THANKS REACT.hdjrudni | 9 hours ago
nvme0n1p1 | 2 hours ago
hdjrudni | 9 hours ago
That needs to emphasized more. Pretty sure React's Suspense suffers from waterfalls if memory serves.
dmix | 20 hours ago
[OP] pier25 | 20 hours ago
https://krausest.github.io/js-framework-benchmark/current.ht...
Between Solid, Vue, and Svelte it's more a matter of features and personal preference than performance at this point.
intellix | 15 hours ago
baxuz | 20 hours ago
techpression | 19 hours ago
I much prefer Solid over React, but at least the idea of a compiler makes so much more sense instead of manually maintaining memoization.
miguel-muniz | 18 hours ago
Tade0 | 6 hours ago
Turns out the secret to fine-grained reactivity all this time was just a tree structure describing the dependencies.
I'm using signals in Angular and while they don't cover every use case cleanly, they're a huge upgrade compared to RxJS Observables - particularly due to how simple and debuggable they are in comparison.
extremeracer | 17 hours ago
The bundle (Solid JSX compiled with the new babel plugin) runs in QuickJS-ng on the watch; the renderer emits node mutations over a small host interface; a Swift host lays them out with Yoga and draws with SwiftUI. The same bundle runs in a browser harness for development. The structure is borrowed from React Native's Fabric: three trees, batched commits, one schema that generates the prop code for both sides. A dozen node types, React Native style names, on purpose.
For context, it's the display layer of a larger personal project (not open source at this point): application state lives in a small expression language with a Rust evaluator, running on the phone or on an ESP32 box, with the state, events and view described by JSON Schemas and a schema-derived wire codec. The watch and an e-ink display are synced views of that state. Bundles and firmware are served and updated over BLE, and the phone app has a sign-in-with-ChatGPT authoring mode that writes the Solid UI and the expression logic against those schemas, checks them on the device, and packs the bundle locally on the phone, no server. Solid's universal renderer is what made the watch part feasible: the UI author writes ordinary JSX and the same bundle runs on the wrist and in a browser tab.
Rough edges in the public piece: you build the QuickJS xcframework yourself, and getting a bundle onto a real watch still means an Xcode build. Examples built with plain npm and the browser harness are in the repo if you want to poke at it. Moving from the RCs to 2.0.0, the only breaking change I hit was <Show> compiling to a ternary, which only reordered mutations inside a commit.
dalmo3 | 15 hours ago
extremeracer | 15 hours ago
troupo | 11 hours ago
AFAIK React has never had a properly defined renderer, and it was a pain to swap out
intellix | 15 hours ago
I think with the advent of AI it doesn't matter so much about the DX and your main focus should be on better UX (the best lighthouse metrics) though I don't think their DX is bad either.
FlameWolf | 14 hours ago
altano | 12 hours ago
My counter component bundle test is:
tommica | 12 hours ago
whizzter | 4 hours ago
slowmotarget | 8 hours ago
> The +11.7KB gzip is mostly Solid 2.0’s runtime and the @solidjs/signals scheduler
skrebbel | 12 hours ago
simongray | 11 hours ago
hdjrudni | 9 hours ago
I didn't like it then either.
unlog | 8 hours ago
dankobgd | 8 hours ago
mkgiga | 6 hours ago
varispeed | 4 hours ago
WuxiFingerHold | 3 hours ago
hombre_fatal | 2 hours ago
They all convinced me to use their respective languages by sharing all the thought they put into them, especially to address problems in the alternative, more popular options.