gorbypark

You could try sandbox-exec. It’s kind of depreciated but was more or less designed for this exact use case I think. It’s too bad Apple doesn’t really support it anymore (although it still works in my limited testing!)

For sure, Claude Code specifically has a grep and glob tool (as well as access to bash). The LLM will decide to use those tools to find files, then once it has found matches to what it's looking for, it reads those files into its context. It will then decide if it indeed was a successful match and start working on that file. There's a lot of times it finds a match using grep, reads that into its context and then decides "no, that's not what I was actually looking for..." and moves on.

Unlike some other AI coding IDEs, Claude Code doesn't either keep your entire codebase in context, or use some sort of vector representation and vector search of your code. It basically uses grep to find a keyword it's looking for then reads the file (it can also just read a few lines of a file too) into its context.

It seems to be the "magic" of Claude Code..it's very UNIX like, uses existing tools to do what it needs to do instead of trying to re-invent the wheel, so to speak.

These being mixture of expert (MOE) models should help. The 20b model only has 3.6b params active at any one time, so minus a bit of overhead the speed should be like running a 3.6b model (while still requiring the RAM of a 20b model).

Here's the ollama version (4.6bit quant, I think?) run with --verbose total duration: 21.193519667s load duration: 94.88375ms prompt eval count: 77 token(s) prompt eval duration: 1.482405875s prompt eval rate: 51.94 tokens/s eval count: 308 token(s) eval duration: 19.615023208s eval rate: 15.70 tokens/s

15 tokens/s is pretty decent for a low end MacBook Air (M2, 24gb of ram). Yes, it's not the ~250 tokens/s of 2.5-flash, but for my use case anything above 10 tokens/sec is good enough.

For sure, it was a bit of a simplified example, but you can imagine prompts that are asking the LLM to touch dozens of files at once. A lot of people will use fairly high level requests, "make a screen in my app that does this" and that ends up making screens, components, queries, local state changes, etc etc. It adds up quick having so much in the context at once (and if you /clear the context and ask it to do anything more than one off changes in a file, it's gonna grep and glob it's way through your code looking for the right files)

As a $20 month user, I can tell you in my experience it's "refactoring" jobs that really smash through those tokens quickly. If you do a "write a component that does this" kinda thing, you can use the $20 plan almost an unlimited amount of time. If you are doing "find all instances of ComponentFoo, change to ComponentBar, refactor each screen for correct usage of ComponentBar" kinda things, it's going to grep through your code, find multiple files, read all of them into context and start making changes one by one and/or spin up a subagent to do it. You'll be rate limited pretty quick doing things that way.

Is there really an off peak time, though? I think Anthropic is running on AWS with the big investment from Amazon, right? I'm sure there's some peaks and valleys but with the Americas, Europe and Asia being in different time zones I'd expect there'd be a somewhat "baseline" usage with peaks where the timezones overlap (European afternoons and American mornings, for example). I know in my case I get the most 503 overloaded errors in the European afternoon.

I'm only on the $20 Pro plan, and I'm a big users of the /clear command. I don't really use Claude Code that much either, so the $20 plan is perfect for me. However, a few times I've gotten the "approaching context being full, auto compact coming soon" thing, so I manually do /compact and I run out of the 5hr usage window while compacting the context. It's extremely infuriating because if I could have a view into how close I was to being rate limited in the 5 hour window, I might make a different choice as to compact or finish the last little thing I was working on.

I was under the impression that bikes have a minimum weight in the rules and actual bikes are pretty much always under that weight these days? They then add little lead weights in strategic places the get them to the minimum weight (and help improve balance by placing the weights in the right spots). I'm not sure of the average added weight is, but you'd think it would at least negate some of the weight of the motor/battery (ie: the motor+battery weights 800g but there's 500g of extra average weight added to a bike, so they would only have a +300g bike..)

Note: I know pretty much nothing about racing but I have had that idea in my head for a while about the added weight. Maybe from a friend who told me his bike wasn't UCI compliant because it weighed too little?

Where are you seeing those prices? Cheapest one I see (and it has horrible uptime/throughput numbers) is $0.40/$1.60, and it's more like $2/$2 on average.

Sometimes they are! I use the expo docs as a human all the time. Some project however seem to really "minify" their docs and are less readable. I'm not quite sure how minifying really saves space as it seems like they are just removing new lines as the docs are still in markdown...

Good for humans example: https://docs.expo.dev/llms-full.txt

Bad for humans example: https://www.unistyl.es/llms-small.txt

Nope, I "borrowed" the system prompt and all the tool descriptions / tool schemas. I then re-implementing all the tools based on those descriptions and input schemas. I then used the OpenAI Agent SDK to give a model all the tools. Very conveniently the OpenAI Agent SDK supports different providers, namely the Vercel AI SDK ones, so it can be used with non-OpenAI models. The Vercel SDK has an Anthropic provider so that's how I used it to test.

This could have been somewhat trivial to implement from scratch too (not using the Agent/Vercel SDKs), but it sure made it convient! It's basically one run({model:'sonnet4', prompt: systemPrompt, tools: [tool1, tool2, tool3]}) call. Much nicer than implementing a loop and all that logic by hand.

This is an issue with the prompt and/or the tool descriptions and/or the model.

A MCP server is really just a collection of functions the model can call, and a list of those functions and their description/input params. In theory the MCP connector is calling /get-tools on the MCP servers and injecting that into the prompt, so the model knows which tools are available, their description and input params. It's then up to the model to pick a specific tool to use.

I don't know where specifically the MCP tools are injected into the prompt or what the original system prompt is (ie: maybe it's saying "always give the internal tools priority and only use MCPs if nothing else fits").

It could be the MCP server has poor descriptions of the tool. That is what the model uses to decide to use it or not.

It could also be the model just sucks. Claude Opus/Sonnet seem to be some of the best at tool calling, but it's still up to the model to pick which tools to use. Some models are better than other. Some models start to regress in their tool calling abilities as the context window fills up.

My instinct is the MCP tools have bad descriptions. I've done a bit of reverse engineering of Claude Code and most of the tool descriptions are very detailed. "Use this tool to call a bash command" would be a bad tool description. The Claude Code bash tool description is 110 lines long containing detailed usage information, when to use it, when not to use it, example usage and etc. It also has a summary at the bottom of very important things (that were just written above in the same description) for the model not to forget (they use the word IMPORTANT and YOU MUST a lot in the prompts/descriptions)

There's an attempt to kinda have these things documented for AIs, called llms.txt, which are generally hosted on the web.

In theory, an AI should be able to fetch the llms.txt for every library and have an actual authoritative source of documentation for the given library.

This doesn't work that great right now, because not everyone is on board, but if we had llms.txt actually embedded in software libraries...it could be a game changer.

I noticed Claude Code semi regularly will start parsing actual library code in node_modules when it gets stuck. It will start by inventing methods it thinks should exist, then the typescript check step fails, and it searches the web for docs, if that fails it will actually go into the type definition for the library in node_modules and start looking in there. If we had node_modules/<package_name>/llms.txt (or the equivalent for other package managers in other languages) as a standard it could be pretty powerful I think. It could also be handled at the registry level, but I kind of like the idea of it being shipped (and thus easily versioned) in the library itself.

When you posted this, it would have been 1-3AM in North America (and probably large parts of South America), so yeah, probably mostly Europeans!

I opened up the app bundle of CC on macOS and CC is incredibly simple at its core! There’s about 14 tools (read, write, grep, bash, etc). The power is in the combination of the model, the tools and the system prompt/tool description prompts. It’s kind of mind blowing how well my cobbled together home brew version actually works. It doesn’t have the fancy CLI GUI but it is more or less performant as CC when running it through the Sonnet API.

Works less well on other models. I think Anthropic really nailed the combination of tool calling and general coding ability (or other abilities in your case). I’ve been adding some extra tools to my version for specific use cases and it’s pretty shocking how well it performs!

I started a new project to test out CC and constantly find I have to ask it to fix ts errors…it’s nice I don’t have to tell it what error it is (ie “fix the ts errors in file.tsx”) but I’m surprised it doesn’t have a “check ts” step automatically (i even added something to CLAUDE.md, which seems to work sometimes, but not always). It’s especially bad when working with recently updated libraries. It keeps suggesting thing that don’t exist anymore even though ts clearly knows it’s wrong.

Otherwise CC has been stellar and I live it’s a CLI + optional vs code extension.

I hate to sound like one of those “I could build it in a weekend” types, but I really don’t get why Apple doesn’t just make/buy/license a decent general purpose multimodal LLM and then just create MCP servers for all their various integrations. Hey Siri, turn on the lights -> HomeKit MCP. Hey Siri, what’s the weather -> darksky MCP, and etc. Seems like most of the pieces are there already and they just need to glue it together in a way that works with their risk tolerance profile.

Ah cool, I didn't realize that even their linux VMs are being powered by Hyper-V

Yeah, I've not quite figured out what I'm doing wrong, but sometimes iOS notifications just disappear after clicking on them. I think it's when iOS decides my face isn't good enough (I have an iPhone 11 where the FaceID isn't as good as the newer phones), and then it tries three times and fails...then the notification is dismissed because I clicked on it but I haven't actually unlocked the phone? Then it's gone forever seemingly.

I really really want some kind of write up on that custom m-series hardware. Not very much has even leaked out.

I don’t think many azure services are Linux on hyper-v, are they? Azure (afaik) is quite heavy on bare metal Linux.

I’ve seen some YouTube videos of people making solar fences with bi-facial panels. If I recall correctly on the one I was watching, they were going for morning and evening production and faced them east/west. One side would get the morning light then the other the evening light.

Comfortable is of course subjective, but my current go to for "fancy" shoes is Meermin. For about the price of a pair of higher end Nike or Adidas shoes that are just foam glued to fabric, you can get a pair of "traditionally made" Goodyear welted leather shoes. Meermin, for example, still does some manufacturing steps in China. As far as I know they sew together the leather pieces in China and then ship them to Spain for lasting / final assembly / polishing.

It goes to show how the big athletic shoe companies are taking the piss. Of course they have middlemen and retailers and whatnot who need to take their cut, but if I can buy a pair of nice leather shoes, made from leather from UK/French/Italian tanneries, with about a million steps done by a human, for the same price as some glued together foam and fabric...something is wrong.

Pretty neat! I’m currently working on a project that uses an ESP-C6 that just exposes a “switch” over matter/thread thats based off the results from the Spanish electricity prices API. The idea is have the switch be on when it’s one of the cheapest hours of the day, and off otherwise. Then other automations can be based on it. This was pretty trivial to do in home assistant but I want something that’s ultra low power and can just be completely independent of anything for less technical users. My end goal is to have a small battery powered device that wakes up from deep sleep once a day to check the day ahead prices via WiFi. The C6 might be overkill for this, but once I have a proof of concept working I’ll try and pick something that’s ultra low super ultra low power. Something that needs charging once or twice a year would be ideal.

The ideal form factor might be a smart plug itself, but I can’t find any with hackable firmware and also matter/thread/wifi.

Yeah, I've been playing around with the "new-ish" ESP32-C6 chip. It's a $6 dev board, so probably in the sub dollar range in bulk for the chip itself, and has WiFi 6! I originally thought WiFi 6 meant 6ghz, but it's limited to 2.4ghz.

Open source rules the hidden parts of nearly everything (servers, programming languages, etc). It's atypical for user facing software to be open source and "world class". Of course there are exceptions (like Blender, for example) but generally the commercial version of user facing software is more advanced/well liked/industry standard.

From my (very basic) understanding of GPS you need at minimum four satellites to calculate the time. If you had a local atomic clock in sync with the GPS satellites, you'd only need three satellites to get a position fix. It would (probably, maybe?) also speed up the time to first fix / time to a precise position fix.

Seems interesting. Coming from the react native world, competition is good! This seems to have a from scratch layout engine, which is pretty exciting. It looks like it supports some of the more recent/advanced CSS features. It also has a javascript engine based on QuickJS.

I can't wait for a more technical deep dive into how this works and compares to react native.

Most every OTA channel here in Spain (at least in Valencia) is 1080i, with a few being 720i, but there's two 4K test channels, one SDR and one HDR. Not sure of the bitrate, but the SDR one looks stunning on my TV (which "supports" HDR but looks horrible in HDR mode). They usually just play loops of B roll of various Spanish things, festivals, random clips of theatre productions and things like that. It's pretty neat!

Any sources on some of the tech being used over there?