scottyeager

See: https://support.claude.com/en/articles/15036540-use-the-clau...

The change was "paused" pretty quietly.

It's also a desktop app, integrated into the mobile app, and it has cloud hosted session capabilities too. Plugs into Slack and Github, maybe others. So definitely there's backend stuff as well, beyond the inference.

They never actually made the change. Using -p with a subscription has worked all along.

Definitely raised an eyebrow at this one :D

I picked up a couple of foot pedals built to control manual transcription software from thrift stores. That was years ago and I hacked them to control music software instead. Then one day I got Nvidia's Parakeet model running locally and was sold on automatic transcription in an instant. So in an ironic twist, I started using one of my spare transcription pedals to do transcription by wiring it up to a harness for Parakeet. It's great and the setup is basically trivial to create these days on Linux with a bit of help from an agent.

The next generation of models are currently being withheld from general release. Beyond that, there's still a lot of room to compete on price and also independence from the US labs.

Sure!

Did you mean Sonnet and Opus?

Back then they were both written in Go too. OpenCode was rewritten in TypeScript after Crush got the rename.

Community and listener supported radio stations can be a great resource. I discover a lot of music via a local station I discovered by surfing on the FM dial. Most stations offer online streams these days and some even produce video content too (Live at KEXP is one favorite, and NPR's Tiny Desk is in a similar vein). Non corporate coffee shops are usually playing some music selected by the baristas and I found some favorites that way too.

When I find something new, I like to look up live performances from that artist on YouTube. Sometimes people in the comments mention other similar artists or the source that led them to the video. YouTube's algorithm is a bit of a dark and dangerous thing overall, but I do sometimes follow a suggestion for music that I end up loving.

Refusing future applications to adjust status would be one thing (still wrong, in my opinion). The fact that they are canceling pending applications is simply evil. There will be so much unnecessary anguish and expense. I really feel for anybody who is now learning they will have to leave and wait years to come live in the US with their spouse, due to overstayed visas which were supposed to be forgiven under the status quo.

It's just too bad Emacs doesn't also include a decent text editor, right?

New Nvidia Parakeet release does both offline and streaming. English only and outperforms v2 error rate in offline mode while being very competitive with v2 in high latency streaming mode.

Aider isn't abandoned, but it feels like it's basically in maintenance mode at this point. Updates over the last year were limited to small improvements and fixes. There are some forks aimed at making it more "agentic" (more like Claude Code, etc). I haven't tried them personally.

Do you mean to say Zed wasn't vibe coded? There's actually another comment on this post describing how someone is using Opus 4.5 to work on Zed. Given how forward the AI features are in Zed I'd be surprised if the team wasn't also embracing it internally.

It's a fair question how much AI is accelerating the development of Zed, but I can say that I've been impressed with the speed they are shipping at.

Happens to me even with an ad blocker.

"Significantly Enhanced Multi-Language Programming, Built for Real-World Complex Tasks"

Not the OP, but I did release my source :D https://github.com/scottyeager/Pal

My tool can read stdin, send it to an LLM, and do a couple nice things with the reply. Not exactly RAG, but most man pages fit into the context window so it's okay.

I'm not the OP, but I did build a tool that I use in the same way: https://github.com/scottyeager/Pal

Actually for many cases the LLM already knows enough. For more obscure cases, piping in a --help output is also sometimes enough.

Older cars don't have these systems. Also they are easy to bypass with a dummy buckle. There are counties where seatbelt usage is far less common than the US.

As others have mentioned, a firewall might have been useful in restricting outbound connections to limit the usefulness of the machine to the hacker after the breach.

An inbound firewall can only help protect services that aren't meant to be reachable on the public internet. This service was exposed to the internet intentionally so a firewall wouldn't have helped avoid the breach.

The lesson to me is that keeping up with security updates helps prevent publicly exposed services from getting hacked.

On Linux, the default init program is usually systemd. The main job of the default init program is typically to be a process manager. That is, it starts other programs and can restart them if they crash. Since it's the first process to start (PID 1), if it exits the kernel can't continue and will panic, usually followed by a reboot.

Containers work similarly, except that they don't take the whole system down when their PID 1 exits. That's why containers often don't have a process manager inside, but Linux based operating systems do.

You can read that 3.2 is live on web and app here: https://api-docs.deepseek.com/news/news251201

The pdf describes how they did "continued pre-training" and then post training to make 3.2. I guess what's missing is the full pre-training that absorbs most date sensitive knowledge. That's probably also the reason that the versions are 3.x still.

Personally I found the mini SWE-agent to be a very approachable introduction to building agents: https://github.com/SWE-agent/mini-swe-agent

There are a number of free and cheap LLM options to experiment with. Google offers a decent free plan for Gemini (get some extra Google accounts). Groq has a free tier including some good open weight models. There's also free endpoints on OpenRouter that are limited but might be useful for long running background agents. DeepSeek v3.2, Qwen3, Kimi K2, and GLM 4.6 are all good choices for cheap and capable models.

Local models are generally not a shortcut to cheap and effective AI. It's a fun thing to explore though.

I just did some code to display digits on my APC Mini's 8x8 light grid: https://github.com/scottyeager/pressed/blob/main/controllers...

By using the three available colors on my older model, I was able to render numbers up to 199 in a readable way. Two digits on the right are 8x3 and one on the left is 8x2. I quickly abandoned two pixels of width as impossible for making legible text for all digits, so seeing a full font at two pixels wide is a fun surprise.

Thanks for the tip on Mystrix—looks neat.

Fast inference can change the entire dynamic or working with these tools. At the typical speeds, I usually try to do something else while the model works. When the model works really fast, I can easily wait for it to finish.

So the total difference includes the cost of context switching, which is big.

Potentially speed matters less in a scenario that is focused on more autonomous agents running in the background. However I think most usage is still highly interactive these days.

They have a "max" plan with 120m tokens/day limit for $200/month: https://www.cerebras.ai/blog/introducing-cerebras-code

Haven't seen any issues like this while using a key from their subscription plan: https://www.cerebras.ai/blog/introducing-cerebras-code

Incus is really nice. It manages to provide a rather container-like experience for VMs. Having the ability to grab a shell on or copy files to/from a VM with the ease of using Docker is a great quality of life improvement. This requires an agent running in the VM but it's already included in the images from the project repo.

This is so cool—thanks for publishing it!

I was just starting to study coding agent implementation, specifically with tool use. Seeing the insight on the README that `bash` is all a modern LLM needs to solve coding tasks was very interesting, since the trend seems to be solidly toward tools.

Being able to read the entire agent code nearly on a single screen is very instructive and inspiring to start hacking.

One thing I'm curious about is API calling efficiency. Did you happen to compare request count or token consumption of the mini agent versus full sized? Is that data available generally for the SWE-bench results?