Try many speed fixes at once

Name the slow screen or component. Ask your agent:

Use buoy optimize and the sim farm on our slow feed screen.

That's all you need to say. You don't pick how many ideas. The skill tells the agent to find as many as it can and test them all. Then it goes like this:

1. Ideas. The agent writes down every way it can think of to make it faster. That's at least 20 ideas.
2. Build. It builds the most likely ones first. Each one is its own version of the screen.
3. Look. The farm gives each idea its own sim. The agent opens each idea and takes a picture. An idea that crashes or draws the wrong thing is out.
4. Memory. Each sim acts like a real iPhone SE. An idea that uses more memory than the phone allows is out too.
5. Speed. The ideas that are left get timed on one quiet sim. The old code is timed in every batch too. If the Mac got too busy, the run is marked unfair and done again.
6. Again. The agent keeps what was faster and still looks right. It mixes the best ideas, builds new ones and tests again. It keeps going until it can't make it faster, or your time runs out.

Why only one sim for speed? All sims share the Mac's CPU. Ten sims timed at once would slow each other down. So many sims check looks and memory, and one sim checks speed.

You can watch it in Buoy Desktop. Its Sims panel shows each sim live, with the idea on it and how it's going.

Use buoy optimize and the sim farm on our slow map screen.
Use buoy optimize and the sim farm on the PriceChart component.
Use buoy optimize and the sim farm on the chat screen. Stop after 30 minutes.

1. Set up the Buoy MCP in your editor. Run the command below in your app's folder. It also adds the buoy-optimize skill.
2. Add Bench (@buoy-gg/perf-monitor) to your app. Optimize uses it to time each idea.
3. Build your app for the iOS simulator as a development build. The farm needs the .app file.
4. Ask your agent to use buoy optimize and the sim farm on your slow screen or component.

npx -y @buoy-gg/mcp@latest init

The agent makes a template sim with your app on it. It takes the sims it needs and gives them back when it's done. You need a Mac with Xcode. Buoy Desktop is not needed, but it lets you watch.

A normal sim uses about 5 GB of memory. Most Macs can only run a few. That's too few to try many ideas. Farm sims are slim. They turn off phone services a test doesn't need. Here is what we measured on our test Mac:

Each new sim is a copy of the template, made in about 4 s. Ten slim sims started at once took 94 s and used 15.4 GB in all.

A sim app is a Mac program, so it sees all of the Mac's memory. In our test, one app grew to 20 GB. A real iPhone SE closes an app at about 2.1 GB. So an idea can look fast on a sim only because it keeps everything in memory. On a real phone, that app gets closed. So the farm starts each app as an iPhone SE (2nd generation):

• The app sees the phone's memory (2,957 MB) and 6 cores.
• It gets a memory warning near where the phone would warn.
• Past the phone's limit (2,098 MB), it keeps running. The farm tells your agent a real phone would have closed it.
• At a safety cap, the farm closes the app, so one app can't eat your Mac's memory.

We checked these numbers on a real iPhone SE. Got a different phone? Plug it in and run farm phone measure. It needs a paid Apple Developer team.

A busy Mac can make a good fix look slow. So the farm watches the Mac during each speed test. It marks a run as unfair if the Mac got hot, ran low on memory or had too few free cores. Your agent runs those again and doesn't rank on them. Farm numbers come from a slim sim on your Mac, so check the winner on a real phone before you ship it.

Slim sims have no push, purchases, app links, widgets or Spotlight. If your test needs one, the agent can make a normal sim instead. The farm never touches a sim it didn't make.

npx -y @buoy-gg/mcp@latest farm status
npx -y @buoy-gg/mcp@latest farm phone list
npx -y @buoy-gg/mcp@latest farm phone use off
npx -y @buoy-gg/mcp@latest farm phone measure
npx -y @buoy-gg/mcp@latest farm stop