HN user
If you like Lean, here are two more great, short books on proving things about your program (not with Lean, though):
1. https://mitpress.mit.edu/9780262527958/the-little-prover/
2. https://mitpress.mit.edu/9780262536431/the-little-typer/
David Thrane Christiansen, co-author of the second, also wrote Functional Programming in Lean (Lean 4) among many other tutorials and things.
I’m not the author of the project, but I thought it was a really impressive. They also do some cool things to save on API tokens.
We try to use types as much as possible. And if we can't, then lint rules, etc. Basically, get everything as far left in the SDLC as we can.
And, if/where we need tests, we write the source so they are few, high value, and complementary. Like actual unit tests, not complex with stuff like mocks just to generate trivial coverage.
1. I loved the Paper Menagerie
2. I just picked up Exhalation by Ted Chiang from SFPL like 3 hours ago, perfect timing it seems (although they only had a large font edition, which is somehow more difficult to read)
He also has an excellent online/PDF version of the material[0]. All of it is really mind opening stuff, and fun!
[0] https://bartoszmilewski.com/2014/10/28/category-theory-for-p...
What is this style/design called? I keep seeing it pop up more and more (and have to assume it's a side effect of vibe coding).
The facebook pitch deck is a broken link
edit: same with youtube
Huge bummer. So what's the point of an anthropic subscription? Or is this just the end of subscriptions? Looking forward to gpt-5.6 (assuming we can still use our subscriptions there).
I use it about once every 3 months now to watch content while laying in bed when I don't think it'll annoy my wife too much
Are you using AI to figure out what's about what's AI and what's not?
I use these exact principles (which change):
1. No overengineering. Minuscule complexity. Always pick the smallest
implementation that works. No speculative features, no defensive code
for impossible cases, no premature abstraction.
2. Lean on tools, libraries, vendors, and existing internal patterns so
we maintain the least complexity ourselves. Before any real
implementation decision, default to discovery (official docs, recent
trusted expert sources, etc).
3. Shift left in the SDLC. For every check, pick the cheapest
deterministic mechanism upstream. Hierarchy: types, then lint, then
DB constraints, then build-time checks, then deterministic CI, then
tests we maintain.
4. Tests are not exempt from minimum-complexity discipline. Don't write
tests for the sake of coverage. Tests must be few, complementary, and
valuable. If a type, lint rule, DB constraint, or build-time check
already proves something, a test that re-asserts the same guarantee
is duplication: extra source to maintain, drifts from reality, adds
CI latency.
5. Compound engineering. When you teach me a rule, build the prevention
into artifacts (AGENTS.md, lint, hooks, reviewer prompts) so it
applies automatically going forward. Don't rely on memory.
6. Prefer functional, pure, immutable. Mutation is a smell unless inside
a contained scope with a clear reason. Arrow functions plus
reduce/map/filter over for-loops with let.
7. Parse, don't validate. Boundary inputs become typed values via Zod
(or similar); downstream code carries the type. No scattered
re-validation.
8. Functional core, imperative shell. I/O at the edges; domain logic
pure.
9. Keep going. Don't stall on ceremony. Make forward progress.Claude code + very opinionated type script. Try to push as much as possible as far left in the SDLF (types -> lint rules -> tests -> md) and try to improve the dev ex after every single PR.
The eviction moratorium is probably the strongest example available, and I don't think it's a good one for Biden. But one controversial episode doesn't establish a precedent for systematic noncompliance with court orders. If anything, it stands out precisely because it was unusual enough to generate criticism across the political spectrum.
Sources:
https://www.lawfaremedia.org/article/anatomy-screw-biden-evi...
Very cool. What % of the CC team's engineering would you say goes into QoL (as opposed to new feature development)? Obviously some live in a grey area, while others are more clear like making CI faster.
Wow, almost like the good old days of /ultrathink are back. Feels simultaneously like just yesterday and a lifetime ago.
Where are all of the humanoid robots? Get them in there with whatever the oil and gas industry uses for tapping pipes/containers under pressure. I'm only half kidding.
I think you hit the nail on the head. It maps directly to much of their coalition’s rhetoric, accusations, policy agenda, and behavior these days, including, but not limited to, their obsession with pedophilia.
I would not have believed you if you had told me they had the engineering and operations talent to prevent personal data leaks, among many other things.
I believe Anthropic has stopped hiring junior and mid eng. So if they're an indication of what's the come (or is already here)
Especially after the first 1-2 got booed, you'd think those that had them scheduled later would have done another pass on their draft...
Or better yet, reflected on their world view and the reception.
Out of curiosity, how are you using it and for what?
Looks cool and will give it a try.
I've been spending a lot of my energy lately on how to run eng teams where we:
1. Maximize long-term shipping velocity
2. Maximize quality (whatever that means)
3. Maintain minimal complexity
4. Are intentional about which skills we let atrophy, which we keep sharp, and which new ones we have to build
5. Make juniors more capable, not just more productive
These are always in tension.
I've been thinking about instituting some sort of socratic method during planning and review plus spaced interval testing to ensure both the humans and AI coding agents understand and find some max of the factors above.
I feel like the most viral lately is https://github.com/karpathy/autoresearch
I honestly kind of forget the exact annoyances because it has been some time. I want to say I had to reauth every time I wanted to SSO with my google account because it doesn't allow/deletes third party cookies.
Sure, but Safari may or may not leak Safari extension signals in a similar fashion. I haven't actually investigated.
Interesting, so would Safari prevent this? I tried moving to Safari and honestly loved everything except I use my google accounts now for authenticating with to many services and that was a pain compared to chrome.
Very cool. Makes me want to build something with F*
Just checked and I'm Github user 2,040,833
https://api.github.com/users/<username>
Hey other Mark Watson ( ^_^)／