arthurcolle

I had some interesting last few chats with Claude 4 Opus before this all went down

https://x.com/arthurcolle/status/1927502301385667006

Edit: Looks like its back

Thanks for the correction. I incorrectly recalled from that documentary "Inside Job"

They jailed 1 banker lol

Every single person involved in applied AI deployment needs to fight back

These corporations will destroy people to advance this automation narrative and we can't accept it

The examples definitely need to be changed, but I am considering just throwing away this implementation and restarting as I don't want to be tied to this current typescript implementation and I think I can move a bit faster with Rails.

The underlying pet generation is actual not too bad, but you're fundamentally right -> need to extract features from the core pet content and then use those to generate the sticker assets. I already do this - in fact I have a very advanced pipeline to take 1) OG image -> 2) create 30-50 variants -> 3) compare against stock to get good 8-15 variants -> 4) take those and generate prompts/images that are useful in creating the "final good stock"

From those, if there are multiple images on any single image, I split them. Then, as the user uses the app, the images get packed into one or multiple sheets that are then able to be shipped.

Here are some of the original animals for the sticker examples:

https://x.com/arthurcolle/status/1926469831970165097

I'll fix the app examples. Thanks for the shout.

Thank you, this is critical feedback. I totally know what you mean.

Quick question - you tried upload from main page, or did you create a pet in the dashboard and then generate a sticker from that pet page in the dashboard? Not trying to keep posting this video link, but wondering if you were able to get a sticker wall going in the studio: https://www.youtube.com/watch?v=Xcn8dSt7CcQ

--

ninja edit for myself: Reading back this comment I notice I have too many linguistic abstractions I'm repurposing for this app, but I totally know what you mean @apsurd - and your special snowflake little snicker doodle deserves every variation this construct has to offer.

Thank you for the feedback. Those 'transformation examples' are definitely one thing that I was sloppy with. All of the nice outputs are actually derived from pet photos that are legitimately "visibly similar" to the outputs, but I really wanted to push this out so I didn't do my proper diligence.

Here is a video walkthrough to show you some of the meat around image generation / sticker packing: https://www.youtube.com/watch?v=Xcn8dSt7CcQ

I have been working on more advanced features like 1) splitting images into separate images, and 2) re-packing into a single image sheet after validation that the 'biometric color palate' and the 'specific physical attributes that make this thing the thing it is' passes are both sufficiently high in terms of confidence level.

I wanted to initially just have a plain vanilla canvas that you plop images into and then have a "Loom" like experience for regenerating images / creating pseudo-pipelines with just touch/mouse commands and more, but I found that users said it was too opaque and required too much 'obscure prompt engineering experience' to click around to make outputs "pretty" (direct quote).

thank you for taking a look @wlesieutre, I really appreciate it

probably meant to look like the new Airbnb design library

Rocket Internet https://en.wikipedia.org/wiki/Rocket_Internet

It's honestly a really good idea in general, but probably fails if you don't execute even faster than incumbents in new markets. Another company in Brazil does this I think.

Companies, even startups, despite "we listen to users" actually move very slowly, and the gap between what is said and what is possible and what is better than currently available (like, in an app) is huge.

ask chatgpt to make the same todo app in flask and fastapi and compare the differences

slowly changes the app into a twitter clone and note the differences

eventually, the differences you find are the knowledge of these frameworks' caveats and advantages

Prime Intellect is a grabby AI :)

yeah

observer:start()

vs.

:observer.start()

To be fair, I want to clarify this is an experimental repo. It would be a dream to eventually properly structure and deploy this in such a way its usable for all downstream consumers, Erlang, Elixir, maybe even weird COBOL RPC (joking)

I posted this because I got some funny outputs (read: deep research quality from gpt-4o over 37 minutes) with a derived repo using this repo, so I figured it was usable enough for others in this immediate space.

If you have any desired functionality, or you want to contribute, please file issues + file pull requests.

I have also been in the Elixir space for around 10 years, so we're in good company! https://github.com/stochastic-thread/snek.ex ;)

In 2035 every process with have a 0.1B LLM running at 60x human capacity, with half the overhead and twice the work! ;)

Erlang is strictly better in all ways for my use-case due to its purity, rigorous simplicity, and direct closeness to the BEAM VM. I also wrote a library 10 years ago to do python->elixir and back. https://github.com/stochastic-thread/snek.ex

When building foundational libraries, especially for large-scale distributed systems or agent-based architectures - I find Erlang’s minimalism, mature toolset (like `observer:start` for visual supervision trees), and battle-tested concurrency model invaluable. I also liked Prolog, so I guess if these preferences are strange, that explains them!

That said, Elixir definitely has enhanced the developer experience significantly. The improved syntax, great macros, `mix`, Hex package management, and community-driven tooling are impressive and inviting for newcomers. Interoperability is excellent, so writing foundational libraries in Erlang makes them readily accessible to Elixir applications without hassle.

A few examples highlighting Erlang’s advantages:

* *Minimalism & Predictability*: Erlang's restricted syntax and clear semantics make large-scale codebases easier to maintain and reason about, crucial when debugging complex distributed agent interactions. * *Tooling & Debugging*: Tools like `observer:start`, built-in tracing with `dbg`, and mature profiling support give unparalleled visibility into running systems. * *Closer to BEAM*: By writing directly in Erlang, I have tighter control and deeper understanding of how my code interacts with BEAM’s scheduling, garbage collection, and process handling.

Still—I love Elixir’s conveniences and often reach for it for web-facing layers, prototyping, or anything user-facing. Both languages complement each other well.

And yes, given my project's name (`Agents.erl`), maybe Elixir needs to rename its `Agent` module now.

Yeah, I would prefer to use Erlang here as I am making this a foundational library for a very large distributed system that I am migrating away from Python to probably Erlang + Rust for an AGI self play project

I want to be as close to the BEAM VM as possible

Do you have a good example of a rebar3 application / umbrella app that would be good to copy in terms of structure? It has been a minute since I last touched erlang so I haven't really set up a proper directory structure myself before. Maybe I should just create a newbranch and try to set it up using Hex or something, not sure

Thanks for mentioning this, it seems I did indeed commit a lot of binary executable files

Whoopsie

One great thing from erlang to be aware of is observer:start, or :observer.start in iex, to check out process supervision trees

over a year ago, this was my same experience

not sure this is shocking

I like using Jupyter Console as a primary interpreter, and then dropping into SQLite/duckdb to save data

Easy to to script/autogenerate code and build out pipelines this way

Absolutely, please reach out! arthur@distributed.systems

Hi, I'm starting an evals company, would love to have you as an advisor!

navigating personal 'unemployment' while obsessively hoarding whatever money I can to run experiments / train, finetune models to leverage RL and environment-building in order to use computers, learn tasks, learn from each other, and scale to managing companies (simple, SaaS at first, and eventually, potentially to real-world operations downstream task sets)

I posted this thread to o3 and found the results interesting. https://chatgpt.com/share/680aad8d-ce54-800c-8973-df4258bbe1...

Segmentation fault! Core dumped

It is an API. You can implement all this stuff from scratch with raw requests library in python if you want. Its the idea of a standard around information interchange, specifically geared around agentic experiences like claude code, (tools like aider, previously, that are much worse) - its like a FastAPI web app framework around building stuff that can helps LLMs and VLMs and model wrapped software in ways that can speak over the network.

Basically like Rails-for-Skynet

I'm building this: https://github.com/arthurcolle/fortitude

if you switch model to GPT-4.5-preview you can spend a lot of money very quickly

Deal. 100K up front ok for development costs?

[Context] https://news.ycombinator.com/user?id=gdlance