interleave
I replied to another sibling: Based on your feedback, I scrapped it all and started over with the actual, unredacted Claude Code transcript plus a personal letter.
https://alexisrondeau.me/mosey-site/conversation/ (Feel free to skip the letter and the final cut)
How does this feel?
https://alexisrondeau.me/mosey-site/conversation/ - (You can skip the letter and the final cut since you already know all of that)
My question still remains: Slop or not?a
You'd definitely see some raw and embarrassing stuff there. Like frustration, anger, greed, ignorance, incompetence, creativity, curiosity.
Is that maybe what we need to see to believe that a human (me n this case) was involved meaningfully?
And I agree with your impression.
My goal here is to understand how can I demonstrate that I did in fact put work and care into the "thing" (video in this case).
Basically show that I did spend energy over time, that the final product took a few dozen iterations with a lot of dead ends (as opposed to a lazy one-shot "make good video, no mistakes")
So I do think this route can have merit given there is actual work, but how would a page like this look if the current one is not yet giving you a trustworthy vibe?
I asked Claude to go through all the previous commits, the chat history and the 100 or so intermediate assets and create a timeline of sorts, the current page as you see it.
It's AI-generated as are the assets, the process and decisions depicted are human.
And still you're reaction is "it's slop". Noted!
This week, I created a video for a personal project using AI.
And, as the creator, I honestly can not say if it's "slop or not."
So I created a "behind the scenes" page that shows the process I went through before final cut, warts and all. You can find it at https://alexisrondeau.me/mosey-site/making-of/
Do you think this helps you decide if it's slop or not?
Twitter is 100% better now than a year ago. For one, I haven't gotten a single bullshit click-farm fake-ass sock-puppet follower in months. Secondly, I see very few low-effort reply guys lately, human or otherwise.
Is it a layout issue for you (it lays out better on desktop) or the language of the text or...? Let me know!
And I wonder: We've got all these amazing (programming) languages to define solutions; where are the languages to clearly define the problems?
The result was: 90% parity achieved with a weird combination of a fine-tuned adapter + 1 deterministic step.
I wrote the whole thing down here: https://alexisrondeau.me/tada/research/FMDiscovery/dashboard... which includes the question, the answer, the 96 experiments and their lineage etc. etc.
https://www.goodreads.com/en/book/show/20821275-arrival-of-t...
https://en.wikipedia.org/wiki/Miller%E2%80%93Urey_experiment
I learned today: The difference between ttf and otf, what strong and weak characters are, what an Em is and where kerning and leading really come from.
My favorite parts: Learning where the magic of ligatures and those tiny postion-changes in moments like "To" come from.
Upvoted and favorited!
As someone who also recently spun up a new VPS to fiddle with claws:
I fully support Hetzner_Online on this because, as a on-and-off customer since 21 years, their service has been absolutely flawless and always worth every cent. They care so I'm totally happy to pay whatever they need to make it work for them, too.
Resource constraints have often helped me come up with stuff that I'm actually proud of.
> What this does: apiKeyHelper tells Claude Code to run echo proxy-managed to get its API key. The sandbox’s network proxy intercepts outgoing API calls and swaps this sentinel value for your real Anthropic key, so the actual key never exists inside the sandbox.
Asking "How would you build a 10k year clock?" is one of my favorite ways to get to know people, say, at parties.
With a few seconds to mull it over, so far EVERYONE has had at least one strong, novel and leftfield idea that I had not heard or thought of before.
My favorites included: A mirror on the moon, bio-engineered crops and the Pyramids of Gizeh.
I call it "moonwalk" because, when throwing away the intermediate vibe-coded prototype code in the middle, it feels like walking backwards while looking forward.
- Check out a spike branch
- Vibe code until prototype feels right.
- Turn prototype into markdown specification
- Throw away vibe'd code, keep specification
- Rebase specification into main, check out main
- Feed specification to our XP/TDD agents
- Wait, review a few short iterations if any
- Ship to production
This allows me to get the best of vibe-coding (exploring, fast iterating and dialing-in on the product experience) and writing production-grade code (using our existing XP practices via dedicated CC sub-agents and skills.)
For reference, here are the two heavy-lifting workers:
- https://github.com/akaalias/bipscan/blob/main/src/c/find_seq...
- https://github.com/akaalias/bipscan/blob/main/src/c/check_se...
and here's a screenshot of the thing running:
- https://x.com/SpringStreetNYC/status/1996951130526425449/pho...
and here's the full story:
LOL, I got 100% nerd-sniped by my friend Sönke this week and wound up building a small spaceship.
On Monday he's like "Hey, what if you found obscure seed phrases embedded in public texts? You'd only need to remember the name of the book and the paragraph and go from there."
I honestly could care less about crypto(currencies) and I'm 100% sure this is like cryptanalysis 101. But, yeah, it seemed like an interesting problem anyways.
First, I downloaded a few hundred books from Gutenberg, wrote a ruby script and found BIP39 word sequences with a tolerable buffer for filler-words.
Then, I was like, okay, gotta now check them against actual addresses. Downloaded a list of funded ETH addresses. Wrote the checker in ruby. Ran it. No hits but this was now definitely weirdly interesting.
Because: And what if I downloaded the whole pg19 text corpus to scan! And what if I'd add BTC addresses! And what if I checked every permutation of the seed phrase!
Everything got really slow once I got to processing 12G of raw text for finding sequences and then checking a few million candidates with 44.000+ variations per candidate.
So, let's rewrite this into C! And since I've got 16 cores, let's parallelize this puppy! And since it's a MacBook, let's use GCD! Optimize all the things!
Lol, so NOW this thing is so fucking FAST. Takes four minutes to go through the full pg19 corpus and generates 64,205,390 "interesting" seed phrases. The fully parallelized checker (see Terminal screenshot) processes 460 derived addresses per second.
I really don't care if I get a match or not. I feel like I started with building a canoo and wound up with a spaceship is in itself just the best thing in the world.
Anyways, in 2016, Tero Parviainen (@teropa) shared this really cool long-form exploration called "JavaScript Systems Music – Learning Web Audio by Recreating The Works of Steve Reich and Brian Eno" that I enjoyed tremendously (and I don't even like Javascript!)
Check it out at: https://teropa.info/blog/2016/07/28/javascript-systems-music...
I was with total certainty under the impression that detecting AI-written text to be an impossible-to-solve problem. I think that's because it's just so deceptively intuitive to believe that "for every detector, there'll just be a better LLM and it'll never stop."
I had recently published a macOS app called Pudding to help humans prove they wrote a text mainly under the assumption that this problem can't be solved with measurable certainty and traditional methods.
Now I'm of course a bit sad that the problem (and hence my solution) can be solved much more directly. But, hey, I fell in love with the problem, so I'm super impressed with what y'all are accomplishing at and with Pangram!
We're a classic XP shop. To build new features in our brown-field app, we defined about 8 sub-agents such as "red-test-writer", "minimal-green-implementer" and "refactorer".
Now all I do in Claude Code is: "Build this feature X using our TDD process and the agents." 30 minutes later the feature is complete, looks better and works better than what I would have built in 30 minutes, is 90% tested and is ready for acceptance testing.
Granted it took us years of working XP, pairing, TDD etc. but I keep feeling confused about posts like this.
We've been shipping production-grade code written 95% by AI for over a year now. Non-trivial, complex features.
There is no secret sauce even, in how we do this. It works. Really, really well for us.
Yet, the most unexpected thing happened this year on my team of 4 senior/staff-level developers:
Instead of "splintering/pairing off with AI" individually even further, we wound up quadrupling (mobbing) full-time on our biggest project to date. That meant four developers, synchronously, plus Claude Code typing for us, working on one task at a time.
That was one of the most fun, laser-focused and weirdly effective way of combining our XP practice with people and AI.
I just posted the results of another basic interview analysis (4o vs. Llama4) here: https://x.com/SpringStreetNYC/status/1923774145633849780
To your point: Do I understand correctly that, for example, by running the default model of Llama4 via ollama, the context window is very short even when the model's context is, like 10M. In order to "unlock" the full context version, I need to get the unquantized version.
For reference, here's what `ollama show llama4` returns: - parameters 108.6B # llama4:scount - context length 10485760 # 10M - embedding length 5120 - quantization Q4_K_M
Edit: 1.4, not 1.7