Pinned Tweet
With its laidback blend of jazzy harmonies and smooth R&B vocals, ‘spinnin’ is the perfect soundtrack to a blissful summer romance
I’m proud to announce my first single ‘spinnin’ is available on all streaming platforms!
isosa.lnk.to/spinnin
#spinnin #RnB #Soul #Pop #Summer #SummerPlaylist #GoodVibes
Green CI should mean ready to ship — not just compiled. 🚦
@AOrobator shares engineering primitives for self-driving Android codebases at droidCon Berlin.
Learn more: eu1.hubs.ly/H0yzCr10
#nextapp26 #AndroidDev
The largest open weight model has 2.8 trillion connections. A dog has about 2.5 trillion.
But the dog spends three quarters of those connections on being a dog. Balance, movement, smell, figuring out if that other dog is friendly.
The model spends all of them on one thing: guessing the next word.
That's why it can write an essay and your dog can't. And why your dog can catch a ball and it can't.
2.8 trillion connections sounds massive until you realize a golden retriever has the same number and still runs into glass doors.
Slides from my Sovereign AI talk at @FreedomLabNYC:
docs.google.com/presentation…
ok this one is stupidly good. try it on 5.6 sol extra high in codex!
it plays straight into codex's new strengths, parallel subagents and computer use, and lets 5.6 sol carry a goal all the way to done.
the prompt 👇
I have one complete task to push end to end: [your spec doc, or the full task in detail]. treat it as one end-to-end goal: 𝘁𝗮𝗸𝗲 𝘁𝗵𝗲 𝘄𝗵𝗼𝗹𝗲 𝗽𝗹𝗮𝗻 𝘁𝗼 𝗱𝗼𝗻𝗲, until architecture, implementation, tests, review and the final result all clear the bar. break the goal into independent parts, spawn as many parallel agents as it takes, and give each one its own goal with a clear deliverable, a verification method, and done criteria.
then run it like an operator: schedule the agents in parallel, track progress, synthesize what comes back, resolve conflicts, keep implementing, verify live after every important step, review when it matters, commit when it's ready, and close with a final summary. verification must cover the real end-to-end path: browser and computer use, clicks, keyboard, whatever it takes. don't stop at partial progress unless you're blocked by missing credentials, destructive ambiguity, or conflicting requirements.
I spent the morning picking a new daily-driver model.
Ran the same prompt through Grok 4.5, Opus 4.8, and GPT 5.6. All three agreed Grok gave the most complete answer, though each wanted to fold in pieces from the others. When I asked Grok to judge, it conceded Claude's plan was better.
So I moved to Grok 4.5 as my daily driver and kept the others on review duty.
Then I had Opus 4.8 and GPT 5.6 look over Grok's work. GPT found no issues. Opus found nits. Same artifact, same prompt, different blind spots.
This is why I audit every model with the others, no matter how good the one I'm running feels that week.
Picking a daily driver is a speed call. Auditing its output is a trust call. Collapse the two and you ship confident, wrong code.
Every model is sure of itself in a slightly different set of places. The panel exists to catch what my favorite missed.
had a blast talking about the primitives of self driving codebases at @aiDotEngineer world’s fair yesterday! thanks for having me! the record will be released soon, but feel free to read my blog if you’re feeling impatient
medium.com/@andreworobator/v… – at San Francisco, CA
Andrew Orobator retweeted
Replying to @rronak_
- Gwern had a fantastic post on day-dreaming, not exactly applicable here, but a similar principle. Tapping into a collection of prior knowledge and creating random associations to explore for novel ideas.
- In a sense many developers are already intimately familiar with the concept of compaction, not only through what used to be the frustration of coding agent compaction, but through compaction of their workflows (trajectory 😉) in the form skills. Though this is not necessarily dream time, it is still expending tokens to explore optimizations (save time on next iteration of workflow).
- For real dream time compute do what @AOrobator is doing with kicking off a compaction step to consolidate, edit, remove, and organize skills.
Andrew Orobator retweeted
First AI After Five is in the books 👾 here's the TLDR
@ShaFrasier built a music knowledge graph in Obsidian using Claude
> 10,000 albums tracked across 7 years
> interconnected notes linking streaming to academic scholarship.
Highlight takeaway: AI isn't only about efficiency but rigor especially in applying your taste
@AOrobator (senior android engineer @ Reddit) on why your AI agent needs a bedtime
> offline memory consolidation modeled on biological sleep cycles
> complete with a 2am cron job and morning brief
Highlight takeaway: memory systems drift just like codebases do, and the fix is the same thing biology figured out. scheduled offline maintenance
full recording if you couldn't make it. more of these to come!
youtube.com/live/bafd4tWA4zg
Andrew Orobator retweeted
We are hosting a night of talks covering LLM knowledge bases and untapped agent efficiency techniques next week at Vellum HQ
@AOrobator and @ShaFrasier will be our main speakers, with time to hang and connect after
> April 15th
> Flatiron NYC
> Free food + Drink
This is the first event in our new series focusing on bringing the AI community together and sharing learnings: AI After Five
See you soon 👾
luma.com/w080zw4u
LLM Knowledge Bases
Something I'm finding very useful recently: using LLMs to build personal knowledge bases for various topics of research interest. In this way, a large fraction of my recent token throughput is going less into manipulating code, and more into manipulating knowledge (stored as markdown and images). The latest LLMs are quite good at it. So:
Data ingest:
I index source documents (articles, papers, repos, datasets, images, etc.) into a raw/ directory, then I use an LLM to incrementally "compile" a wiki, which is just a collection of .md files in a directory structure. The wiki includes summaries of all the data in raw/, backlinks, and then it categorizes data into concepts, writes articles for them, and links them all. To convert web articles into .md files I like to use the Obsidian Web Clipper extension, and then I also use a hotkey to download all the related images to local so that my LLM can easily reference them.
IDE:
I use Obsidian as the IDE "frontend" where I can view the raw data, the the compiled wiki, and the derived visualizations. Important to note that the LLM writes and maintains all of the data of the wiki, I rarely touch it directly. I've played with a few Obsidian plugins to render and view data in other ways (e.g. Marp for slides).
Q&A:
Where things get interesting is that once your wiki is big enough (e.g. mine on some recent research is ~100 articles and ~400K words), you can ask your LLM agent all kinds of complex questions against the wiki, and it will go off, research the answers, etc. I thought I had to reach for fancy RAG, but the LLM has been pretty good about auto-maintaining index files and brief summaries of all the documents and it reads all the important related data fairly easily at this ~small scale.
Output:
Instead of getting answers in text/terminal, I like to have it render markdown files for me, or slide shows (Marp format), or matplotlib images, all of which I then view again in Obsidian. You can imagine many other visual output formats depending on the query. Often, I end up "filing" the outputs back into the wiki to enhance it for further queries. So my own explorations and queries always "add up" in the knowledge base.
Linting:
I've run some LLM "health checks" over the wiki to e.g. find inconsistent data, impute missing data (with web searchers), find interesting connections for new article candidates, etc., to incrementally clean up the wiki and enhance its overall data integrity. The LLMs are quite good at suggesting further questions to ask and look into.
Extra tools:
I find myself developing additional tools to process the data, e.g. I vibe coded a small and naive search engine over the wiki, which I both use directly (in a web ui), but more often I want to hand it off to an LLM via CLI as a tool for larger queries.
Further explorations:
As the repo grows, the natural desire is to also think about synthetic data generation + finetuning to have your LLM "know" the data in its weights instead of just context windows.
TLDR: raw data from a given number of sources is collected, then compiled by an LLM into a .md wiki, then operated on by various CLIs by the LLM to do Q&A and to incrementally enhance the wiki, and all of it viewable in Obsidian. You rarely ever write or edit the wiki manually, it's the domain of the LLM. I think there is room here for an incredible new product instead of a hacky collection of scripts.
Andrew Orobator retweeted
App Store screenshots shouldn’t take hours.
I built a Claude Code Skill that generates production ready screenshots for your app and deploys them to a powerful online editor so you can iterate as much as you want ❤️🔥
Just pull it into your project and go.
Andrew Orobator retweeted
Hello everyone! 👋
The 204th issue on #SoftwareTesting is out.
👉 softwaretestingnotes.substac…
Great articles and resources by @PricillaBelwin, @lifeofqa, @theQualityDuck, @RyanCraven_QA, @GreenReportBlog, @AOrobator and more ! 👏
#QA #testing
AI sessions end. Context vanishes. Tomorrow you're re-explaining everything.
Unless you have a worklog.
Part 4 of Vibe Engineering: Worklogs — How AI Work Persists Over Time 🧵
After the Linus review:
• 787 → 136 lines
• 7 → 4 commits
Same technical content. Everything else was documentation for documentation's sake.
The rule: 50-100 lines for most features. If your worklog is longer than your implementation, cut it.
Starter kit: github.com/AOrobator/vibe-en…
Full article: medium.com/@andreworobator/v…
This is Part 4 of a 7-part series on AI-assisted development.
Next: The Feedback Loop — How Systems Improve Themselves
















