The ampersand method in the OP video (and the sibling slipped-lapp-knot comment) is needlessly complicated. Just follow this super simple animation instead (except pass a bight in the last step to make it quick-release).
The Lapp knot (aka. lapp bend) is my favourite of all the knots and very underrated. It's so versatile and simple, even simpler to tie than a square knot. As shown in the OP, it can be tightened and loosened and explodes when you pull the tag rather than leaving the half-knot behind. It is my default way to tie two ropes together.
I jumped from Google to Facebook on 2019 and while I had thought Google had best in industry developer tooling, Facebook had it better.
Google’s dinky browser based Cider was cute but Facebook in its transition from Atom to VS Code was far ahead. Google might have invented asynchronous web based code review with Mondrian and Critique, but Facebook’s Diff was better with its stacked diff support. Google’s Buganizer was outdated and clunky compared to Facebook’s Tasks.
I left Facebook the year after but I do wonder where Meta’s tooling is up to nowadays. Is it still a glimpse of the future?
The specs are inscrutable agent slop. I want it to tell me what it does and instead it just lists database fields. It mentions a state machine and then proceeds to not describe the state machine.
If I wasn’t so attuned to agent slop, I’d be thinking I’m just too dumb to get it but no, whatever GPT model wrote this is not good enough (and the fact this was published by OpenAI suggests this is not an operator skill issue).
The root cause is that the TUI is just not the right surface an agentic coding tool. If it were a GUI with mouse support and other rich affordances, it'd be trivial to click to expand
If anyone sees this, I tried it and unfortunately am not getting better results on the pelican-on-bicycle test. I think the vision models just aren't good enough yet (I tried Claude and Gemini)
Free idea: turn this into an MCP server. Give the agent the ability to virtually "hover" a path and see which part of the final render it corresponds to
I made a /split-commit prompt that automatically splits a megacommit into smaller commits. I've found this massively helpful for making more reviewable commits. You can either run this yourself or send this to your coworker to have them run it before asking you to re-review it.
Sometimes it doesn't split it among optimal boundaries, but it's usually good enough to help. There's probably room for improvement and extension (eg. re-splitting a branch containing many not-logical commits, moving changes between commits, merging commits, ...) – contributions welcome!
Idea: a general tool that helps you write command lines. It reads the help or man page and generates a GUI or TUI to present all the options in a logical way. You just fill out the form and it does the thing
I actually think this is antithetical to the philosophy. Cyclometic complexity is very much not the same as "is this code difficult to understand".
Arbitrary structure rules like "do_thing_a(); do_thing_b(); do_thing_c();" also is not unless you can explain how this helps make it easier to understand compared to say, one big function with "// DO THING A" comments.
This was my main takeaway from A Philosophy Of Software Design by John Ousterhout. It is the best book on this subject and I recommend it to every software developer.
Basically, you should aim to minimise complexity in software design, but importantly, complexity is defined as "how difficult is it to make changes to it". "How difficult" is largely determined by the amount of cognitive load necessary to understand it.
The closest we got to vibe coding pre-LLMs was using a language with a very good strong type system in a good IDE and hitting Ctrl-Space to autocomplete your way to a working program.
I wonder if LLMs can use the type information more like a human with an IDE.
eg. It generates "(blah blah...); foo." and at that point it is constrained to only generate tokens corresponding to public members of foo's type.
Just like how current gen LLMs can reliably generate JSON that satisfies a schema, the next gen will be guaranteed to natively generate syntactically and type- correct code.
The ampersand method in the OP video (and the sibling slipped-lapp-knot comment) is needlessly complicated. Just follow this super simple animation instead (except pass a bight in the last step to make it quick-release).
The Lapp knot (aka. lapp bend) is my favourite of all the knots and very underrated. It's so versatile and simple, even simpler to tie than a square knot. As shown in the OP, it can be tightened and loosened and explodes when you pull the tag rather than leaving the half-knot behind. It is my default way to tie two ropes together.