vibe42

I could find 3I/ATLAS using the search box for "ATLAS".

Would it be possible to also have the search for "interstellar" list objects classified as interstellar object?

Curious if a harness that helped preserve signals in some history log would change the outcome.

Also curious if different goal prompts would have changed the outcome. Not a bunch of prompt engineering; small diffs like "consider novel solutions, keep track of weak signals".

IMO they allocated quite a bit of GPU time to the same goal prompt.

That's a modern gaming laptop; cheapest I see in the US with 24GB is $3.5k.

Should be quite a bit faster than the new M5 MacBook Pro, and you can run Linux on it!

It's very capable on almost any coding task I've thrown at it, and very good for easy-to-medium hard scripts, new code bases.

It struggles on some complex tasks in larger code bases, e.g. using to debug and fix bugs in llama.cpp it gets close to working code but often introduces errors. For such tasks its still very useful as a search/explore tool and drafting fixes.

E.g. some findings first classified as moderate priority often get reclassified as low priority even if the finding itself is correct.

The exact phrasing doesn't seem to matter as much as keeping the prompts short, simple and to the point.

However some models seem to do a bit better when adding ", if any" to prompts such as "List potential improvements".

I'd run the following 5-10 times with one model, then again with a 2nd model.

"Verify the correctness and completeness of all security configs/rules in SETUP.md. Consider if anything is missing, and if anything is not needed. Do not modify any files; only write potential findings to report.txt"

"Verify all findings and claims in report.txt."

Replace "SETUP.md" with whatever you're working on.

It's both terrifying and incredible watching what the models get correct and what they get completely wrong.

However, after enough runs they tend to settle on a state they claim does not need any more edits. And that result is generally useful with much fewer errors/hallucinations compared to a single run.

The increase in compute (decrease in brute-force cost) combined with price increases in many crypto tokens means brute-forcing old wallets can become worth it years after passwords were forgotten.

And of course even smaller, local AI models can now easily write optimized scripts to brute-force any given KDF function.

One set of models run on 8GB VRAM / 16GB RAM and another set runs on 24GB VRAM / 64GB RAM. Both are very useful for easy and easy-to-moderate complex code, respectively.

The latest open, small models are incredibly useful even at smaller sizes when configured properly (quant size, sampling params, careful use of context etc).

Bit of a hype madhouse whenever a new model is released, but it's pretty easy to filter out simple hype from people showing reproducible experiments, specific configs for llama.cpp, github links etc.

I've used this to debug some moderately complex bugs in golang and godot code and it works really well - the combo of having a new context with the (sometimes overly) granular debug logging and only the required, specific source code.

I use the pi-mono coding agent with several different new open models running locally.

The simpler and more precise the prompt the better it works. Some examples:

"Review all golang code files in this folder. Look for refactor opportunities that make the code simpler, shorter, easier to understand and easier to maintain, while not changing the logic, correctness or functionality of the code. Do not modify any code; only describe potential refactor changes."

After it lists a bunch of potential changes, it's then enough to write "Implement finding 4. XYZ" and sometimes add "Do not make any other changes" to keep the resulting agent actions focused.

"Do not modify any code; only describe potential changes."

I often add it to the end when prompting to e.g. review code for potential optimizations or refactor changes.

Interesting pros/cons vs the new Macbook Pros depending on your prefs.

And Linux runs better than ever on such machines.

The way this could happen is if model commoditization increases - e.g. some AI labs keep publishing large open models that increasingly close the gap to the closed frontier models.

Also, if consumer hardware keep getting better and models get so good that most people can get most of their usage satisfied by smaller models running on their laptop, they won't pay a ton for large frontier models.

I'm playing with a space game idea of physics simulation somewhere between the fidelity of KSP and Eve Online. More robust ships and easier gameplay than KSP, but much more in-depth physics than Eve.

A bit too early (and too much AI slop code!) to share but can push to github if useful - wrote some scripts to parse the gaia DR3 release: https://gea.esac.esa.int/archive/

Parses all rows of the gdr3/Astrophysical_parameters/ files and filters out all objects within X ly of our solar system.

Same idea there as with the exoplanets; build a statistical distribution from real-world data and use it to generate fictional solar systems.

They're helping close to the distance to realistic quality inference on phones and other smaller devices.

If the whole AI bubble spectularly collapes, at least we got a lot of cool pics of custom hardware!

https://exoplanetarchive.ipac.caltech.edu/cgi-bin/TblView/np...

Download Table -> All Columns, All Rows.

Tried a few new, open, local AI models by giving them the CSV file and asking them to write a simple python script:

1. Parse all rows and build statistical distribution of mass, radius etc.

2. Use those distributions to generate fictional exoplanets.

Playing with this for a space game idea where star systems are populated with fictional exoplanets, but all their params are from the real statistical distributions of all known exoplanets.

A way to get some harder sci-fi using real world data :)

A few robot legs and arms, big battery, off-the-shelf GPU. Solar panels.

Prompt: "Take care of all this land within its limits and grow some veggies."

https://svs.gsfc.nasa.gov/vis/a000000/a005500/a005536/a2_fly...

Hope we get to see something like this in 4K !

Moderate geomagnetic storm watch until April 2.

https://github.com/badlogic/pi-mono/tree/main/packages/codin...

This might not be enough to chew through a large code base but for smaller projects it can easily fit enough if not all of the code base to drive a good coding agent.

I don't recommend specific models or model providers due to how much hype and BS there is around benchmarks etc. Easiest is to check the latest generation of open models and look for a dense-type where a decent quant fits within the VRAM.

Some models run fast enough that some of the weights can spill over from VRAM to RAM while maintaining a usable prompt/token gen speed.