colonCapitalDee

I have a custom skill-creator skill that contains this:

> A common pitfall is for Claude to create skills and fill them up with generated information about how to complete a task. The problem with this is that the generated content is all content that's already inside Claude's probability space. Claude is effectively telling itself information that it already knows!

> Instead, Claude should strive to document in SKILL.md only information that:

> 1. Is outside of Claude's training data (information that Claude had to learn through research, experimentation, or experience) > 2. Is context specific (something that Claude knows now, but won't know later after its context window is cleared) > 3. Aligns future Claude with current Claude (information that will guide future Claude in acting how we want it to act)

> Claude should also avoid recording derived data. Lead a horse to water, don't teach it how to drink. If there's an easily available source that will tell Claude all it needs to know, point Claude at that source. If the information Claude needs can be trivially derived from information Claude already knows or has already been provided, don't provide the derived data.

For those interested the full skill is here: https://github.com/j-r-beckett/SpeedReader/blob/main/.claude...

There are no models that you can run locally that'll match a frontier LLM

C's package management story is unfriendly to say the least. A header only library simplifies it dramatically, and makes it much more straightforward to integrate dependencies into your application.

Oh interesting, we had an internal mandate not to use Notepad++ come down from on high that was never explained. The timing matches up

Great news. I was just starting to explore creating a goto-definition skill for CC, glad I don't have to figure that out now :)

Before the first loop iteration, the harness sends a message to the LLM along the lines of.

<Skills>

  <Skill>

    <Name>postgres</Name>

    <Description>Directions on how to query the pre-prod postgres db</Description>
            <File>skills/postgres.md</File>

  </Skill>

</Skills>

The harness then may periodically resend this notification so that the LLM doesn't "forget" that skills are available. Because the notification is only name + description + file, this is cheap r.e tokens. The harness's ability to tell the LLM "IMPORTANT: this is a skill, so pay attention and use it when appropriate" and then periodically remind them of this is what differentiates a proper Anthropic-style skill from just sticking "If you need to do postgres stuff, read skills/postgres.md" in AGENTS.md. Just how valuable is this? Not sure. I suspect that a sufficiently smart LLM won't need the special skill infrastructure.

(Note that skill name is not technically required, it's just a vanity / convenience thing).

It certainly reads like it

Good luck! Building the next uv is certainly ambitious, but I love ambitious projects :)

I don't know why that matters? The city selection and routing is a part of the overall autonomous system. People get to where they need to be with fewer deaths and injuries, and that's what matters. I suppose you could normalize to "useful miles driven" to account for longer, safer routes, but even then the statistics are overwhelmingly clear that Waymo is at least an order of safer than human drivers, so a small tweak like that is barely going to matter.

Blind leading the blind, but my thinking is this:

1. Use the tools to their fullest extend, push boundaries and figure out what works and what doesn't

2. Be more than your tools

As long as you + LLM is significantly more valuable than just an LLM, you'll be employed. I don't know how "practical" this advice is, because it's basically what you're already doing, but it's how I'm thinking about it.

Great article. Can confirm, writing performance focused C# is fun. It's great having the convenience of async, LINQ, and GC for writing non-hot path "control plane" code, then pulling out Vector<T>, Span<T>, and so on for the hot path.

One question, how portable are performance benefits from tweaks to memory alignment? Is this something where going beyond rough heuristics (sequential access = good, order of magnitude cache sizes, etc) requires knowing exactly what platform you're targeting?

Well that's your problem. Here's a tip: just because someone says something doesn't mean you have to listen to them

No. This is far beyond the capabilities of current AI, and will remain so for the foreseeable future. You could let your model of choice churn on this for months, and you will not get anywhere. It will be able to reach a somewhat working solution quickly, but it will soon reach a point where for every issue it fixes, it introduces one or more issues or regressions. LLMs are simply not capable of scaffolding complexity like a human, and lack the clarity and rigorousness of thought required to execute an *extremely* ambitious project like performant CUDA to ROCm translation.

Yep, just checked, 2 GB RAM. That CX23 sounds like a great deal, 20 TB of free outgoing is ridiculous. But I live in west us and I rarely hit my 1 TB free bandwidth cap anyway, so the added latency isn't worth it

I have a tiny Hetzner VPS (2 vCPUs, 2 Gb RAM) in their west us datacenter that costs me $5.59 a month. I get 1 TB a month free outgoing bandwidth and unlimited incoming bandwidth, plus additional outgoing bandwidth at a rate of $1.20 per TB. I host my personal project's git LFS server there, a file server, and a Caddy instance that proxies over Tailscale to a more powerful box in my apartment. It's a great homelab architecture and I couldn't be happier with it. Thanks Hetzner!

I thought this was informative: https://minusx.ai/blog/decoding-claude-code/

Ok, maybe I oversold this a little bit. It's running smooth now, getting it to run smooth was not easy. I'm on Ubuntu. I spent a few days in a debug loop. Run steam from the terminal to get a log stream, keep an eye on CPU and GPU utilization and temperature, and futz around in the training range or vs AI bots (more "realistic" than training range). Identify which components of the system aren't performing up to spec. CPU running hot? GPU not being utilized? Steam emitting warning messages? If hardware all looks good, it's probably a software problem somewhere. Identify, then fix. Rinse and repeat until linux performance is in the same league as Windows performance.

Things I'd try:

1. Check in game graphics settings

2. Update graphics drivers to the recommended version (may be non-trivial, I had to update my kernel version)

3. Experiment with different proton versions, including proton GE

4. Experiment with different Direct X versions (in game option)

5. Make sure CPU cooler is running

6. Make sure GPU is being used

7. Use gamescope to configure a virtual monitor that exactly matches the capabilities of your physical monitor

I've been happily playing Overwatch 2 on Linux for a couple months now. I need gamescope to get it to play nicely with my multiple monitors, and it crashes maybe once a month, but performance is great and I have no major complaints. I'm never going back to Windows, except for work where it isn't optional :(

Is compound assignment atomic in any major language?

Autorotate everything

I think cooling in a chip vs cooling in space are two orthogonal problems. In a chip, the problem is getting the heat to the heatsink where it can be efficiently dissipated into the much larger heatsink of the surrounding environment. In space, the problem is that the only way to dissipate heat is thermal radiation because you're in a vacuum.

People keep coming up with alternate measures and then finding that they correlate pretty well with GDP

It's harder then it first seems. The root problem is that for text like "hallo", correcting to "hello" may be fixing an error or introducing an error. In general, the more aggressive your error correction, the more errors you inadvertently introduce. You can try and make a judgement based on context ("hallo, how are you?"), which certainly helps, but it's only a mitigation. Light error correction is common and effective, but you can't push it to a full solution. The only way to fully solve this problem is to look at the entire document at once so you have maximum context available, and this is what non-traditional OCR attempts to do.

AGI is when a computer can accomplish every cognitive task a typical human can. Given tools to speak, hear, and manipulate a computer, an AGI could be dropped in as a remote employee and be successful.

Half the country is wrong. I agree that centralized ownership is a problem regardless of party, but putting on both sides blinders is not the answer.

BTC means they can pull wealth out of the system at astonishing rates. Trump & Co are hardly the first to be corrupt, but the scale, the blatentness, and the damage being done to the country as a byproduct is unprecedented in modern history

Yep, I graduated and got my first job in 2022 when the market was hot and ChatGPT was a fun novelty. Very lucky

Claude (possible all LLMs, but I mostly use Claude) LOVES this pattern for some reason. "If <thing> fails/does not exist I'll just silently return a placeholder, that way things break silently and you'll tear your hair out debugging it later!" Thanks Claude

I like how Frederick Brooks put it:

"""

Why is programming fun? What delights may its practitioner expect as his reward?

First is the sheer joy of making things. As the child delights in his mud pie, so the adult enjoys building things, especially things of his own design. I think this delight must be an image of God's delight in making things, a delight shown in the distinctness and newness of each leaf and each snowflake.

Second is the pleasure of making things that are useful to other people. Deep within, we want others to use our work and to find it helpful. In this respect the programming system is not essentially different from the child's first clay pencil holder "for Daddy's office."

Third is the fascination of fashioning complex puzzle-like objects of interlocking moving parts and watching them work in subtle cycles, playing out the consequences of principles built in from the beginning. The programmed computer has all the fascination of the pinball machine or the jukebox mechanism, carried to the ultimate.

Fourth is the joy of always learning, which springs from the nonrepeating nature of the task. In one way or another the problem is ever new, and its solver learns something: sometimes practical, sometimes theoretical, and sometimes both.

Finally, there is the delight of working in such a tractable medium. The programmer, like the poet, works only slightly removed from pure thought-stuff. He builds his castles in the air, from air, creating by the exertion of the imagination. Few media of creation are so flexible, so easy to polish and rework, so readily capable of realizing grand conceptual structures....

Yet the program construct, unlike the poet's words, is real in the sense that it moves and works, producing visible outputs separate from the construct itself. It prints results, draws pictures, produces sounds, moves arms. The magic of myth and legend has come true in our time. One types the correct incantation on a keyboard, and a display screen comes to life, showing things that never were nor could be.

Programming then is fun because it gratifies creative longings built deep within us and delights sensibilities we have in common with all men.

"""

Agreed. This is how I feel using it: https://xkcd.com/297/. It's from 2012! I hadn't even written my first `public static void main(string[] args)` then.

My favorite parts of TPL Dataflow are using Channels + Encapsulate to create custom blocks, backpressure, and parallel execution while maintaining ordering. Great library. I sometimes wonder if it would be possible/useful to implement a TPL Dataflow 2.0 on top of Channels.