pglevy

I guess it depends on your definition of "basic minimum sport/hobby/inheritance things." The point is to put some guardrail in place, otherwise you end up spending money for years on stuff you don't see except when you move it to a different bin. It forces you to make decisions.

Way to have a plan and stick to it. If it's necessary, good idea to set a deadline.

We call these "above-ground landfills." After watching (and helping) my parents shuffle stuff around these facilities for years, we drew a hard line in our household: no external storage. If it doesn't fit in the space we live in, we're not keeping it. Great article!

Mostly use homegrown skills. For shared skillset at work, it's a standalone repo with a script for everyone to install the full set. For a personal collection I also use a script to sync a few upstream ones to keep everything in one place.

For evals I use the method outlined in the `skill-creator` skill from Anthropic.

In the skills, I try to use scripts, along with templates and json worksheets, as much as possible to scaffold and validate the work to make things more consistent and reliable.

You just pick a place and draw it. Being anti-screen and taking a recurring break are not the same thing. You don't have to go full Amish. It's like the weekend. It gives you time and space to do other things, and encourages variation in how you interact with other humans and yourself. We picked Friday evenings to Saturday afternoons, not even a full day, and have been doing it for about 10 years. Easily one of the best quality of life choices we made as a family.

> paragraphs that could be studied and independently

Yes, but after reading BGE, I felt like I had to read all his other books to really understand what he was saying (and others too, Kant, Spinoza, etc). And then re-read BGE.

Also Walter Kauffman's on him is very good. Working through that now.

I happened to dip into Heretics recently and thought, if someone were to publish one of these essays as a blog post today, it would be decried as AI slop. This must be who the models learned to write from.

I recently did a similar thing to get all my private repos off GitHub while keeping the same git workflows and accessibility for other machines on my home network. Now my Pi is the remote for those repos.

I didn't realize initially Marc Newson was involved. Definitely echoes of the 021C.

https://marc-newson.com/ford-021c-concept-car/

> Antigravity, as part of the Google AI Ultra plan, is my daily driver, my workhorse.

There's your mistake right there. There is history. User beware.

Wondering what else I'm using from MS that might be at risk. <glances at TypeScript>

Can't help but think of this I re-read recently from Nietzche:

> When I analyze the process that is expressed in the sentence, "I think," I find a whole series of daring assertions that would be difficult, perhaps impossible, to prove; for example, that it is I who think, that there must necessarily be something that thinks, that thinking is an activity and operation on the part of a being who is thought of as a cause, that there is an "ego," and, finally, that it is already determined what is to be designated by thinking—that I know what thinking is.

I was thinking about this as a bull case for human developers. Seems if you're worried enough to do this you're not going to have LLMs write the new code.

Just tried out Opus 4.6 to make a ground-up new version of a perennial side project: static site podcast player.

For this one I focused on loading speed and reducing interaction with repo. So it processes the images (converting to webp) and loads the feed list from a Gist. Also used the "frontend-design" skill. From brief to ready-to-use took about a couple hours.

https://github.com/pglevy/typod

> I think many people have the skills they need, or can learn them, in order to work with AI agents - they are management 101 skills.

I like his thinking but many professional managers are not good at management. So I'm not sure about the assumption that "many people" can easily pick this up.

Moped for the mind has a nice ring to it

I'm curious to understand more about your use case. I've been working on getting fellow designers out of Figma since it's easier to express intent in code now using LLMs.

He literally brings up a concern he calls the "lethal trifecta" when it's even remotely relevant.

Thanks for sharing! I tried a similar content-in-url approach for a family grocery list app but I couldn't get the url that short. (It worked but it was a bit cumbersome sharing over Whatsapp.) Will see what I can learn from this!

At least one person. https://tonsky.me/blog/centering/

I've been thinking about something like this from a UI perspective. I'm a UX designer working on a product with a fairly legacy codebase. We're vibe coding prototypes and moving towards making it easier for devs to bring in new components. We have a hard enough time verifying the UI quality as it is. And having more devs vibing on frontend code is probably going to make it a lot worse. I'm thinking about something like having agents regularly traversing the code to identify non-approved components (and either fixing or flagging them). Maybe with this we won't fall further behind with verification debt than we already are.

For context, I'm a UX Designer at a low-code company. LLMs are great at cranking out prototypes using well-known React component libraries. But lesser known low-code syntax takes more work. We made an MCP server that helps a lot, but what I'm working on now is a set of steering docs to generate components and prototypes that are "backwards compatible" with our bespoke front end language. This way our vibe prototyping has our default look out of the box and translates more directly to production code. https://github.com/pglevy/sail-zero

Our low-code expression language is not well-represented in the pre-training data. So as a baseline we get lots of syntax errors and really bad-looking UIs. But we're getting much better results by setting up our design system documentation as an MCP server. Our docs include curated guidance and code samples, so when the LLM uses the server, it's able to more competently search for things and call the relevant tools. With this small but high-quality dataset, it also looks better than some of our experiments with fine tuning. I imagine this could work for other docs use cases that are more dynamic (ie, we're actively updating the docs so having the LLM call APIs for what it needs seems more appropriate than a static RAG setup).

> I answered.

I never answer the phone.

Not an engineer but I think this is where my mind was going after reading the post. Seems like what will be useful is continuously generated "decision documentation." So the system has access to what has come before in a dynamic way. (Like some mix of RAG with knowledge graph + MCP?) Maybe even pre-outlining "decisions to be made," so if an agent is checking in, it could see there is something that needs to be figured out but hasn't been done yet.

Mine is a much simpler use case but sharing in case it's useful. I wanted to be able to quickly generate and iterate on user flows during design collaboration. So I use some boilerplate HTML/CSS and have the LLM generate an "outline" (basically a config file) and then generate the HTML from that. This way I can make quick adjustments in the outline and just have it refresh the code when needed to avoid too much back forth with the chat.

Overall, it has been working pretty well. I did make a tweak I haven't pushed yet to make it always writes the outline to a file first (instead of just terminal). And I've also started adding slash commands to the instructions so I can type things like "/create some flow" and then just "/refresh" (instead of "pardon me, would you mind refreshing that flow now?").

https://github.com/pglevy/breadboarding-kit

But not Sonnet?

My use case is a little different (mostly prototyping and building design ops tools) but +1 to this flow.

At this point, I typically do an LLM-readme at the branch level to document both planning and progress. At the project level I've started having it dump (and organize) everything in a work-focused Obsidian vault. This way I end up with cross-project resources in one place, it doesn't bloat my repos, and it can be used by other agents from where it is.

How does this differ from this project? https://github.com/simonw/llm

This way of putting it resonates with me: unlocking the value of fuzzy knowledge.