The Computomatix Times

I tried @jack's Buzz.

It's like Slack + OpenClaw + Herdr + but with some really unique features that people are sleeping on.

The video below shows how it works, and some of my thoughts on the process and platform, e.g.:

- Create and interact with agents on top of any harness (claude code, codex, pi, etc.)
- Choose which models agents use, including local ones
- Agents can delegate work and work in parallel in git worktrees
- Agents are first-class citizens and work like humans (creating channels, delegating, access to chat history)
- You can share AI compute within a community
- It's completely open-source and decentralized

Things I like:

- Delegating work in chat feels natural: tag an agent, it replies in a thread with status updates as it e.g. compiles, commits, and deploys.
- Shared compute: relay owners can share local compute with members, so a community could pool funds for one beefy machine running a local model and everyone uses it.
- It's built on Nostr, an open protocol already tied into Bitcoin Lightning so I can imagine communities tipping each other or paying for compute/agent tasks with instant zero-fee micropayments in the future.
- It ties together things like OpenClaw, an agent manager, and Slack-style chat into one tool.

Things I didn't like:

- You can't see what the agent is doing in a terminal. The activity view exists, but if you're used to watching a session run, this UI feels a bit abstracted. A terminal view would be great.
- It feels slower than running a session in Claude Code, though no evidence to back that up. For that reason I found myself doing one-off tasks in the terminal instead.

Verdict:

- I really like it so far and can genuinely imagine working with a team this way.
- It doesn't feel ready for big, complex tasks yet. For shallower tasks, it's perfect.
- The shared compute + Nostr/Lightning angle is what really separates it from every other agent manager for me, and I think that future is coming.

Announcing OpenWorker! An open-source agent that doesn't just chat with you, but delivers finished work -- like hand you a polished document, send a slack message, or update a calendar entry.

Ask it to prepare a customer brief, untangle your calendar, draft a report, or triage a Slack alert. It works across your files and everyday tools, produces the deliverable, and checks in before doing anything consequential.

OpenWorker runs on your Mac, with Windows support coming soon. It does not lock you into any one model. Bring your own API key and run it with GPT 5.6 Sol, Claude Fable, Gemini 3.6, an open weight model (like Kimi, GLM, DeepSeek, Inkling), or Ollama to keep your data local. Your data does not leave your machine except through an LLM provider and integrations that you choose.

@rohitcprasad and I are building OpenWorker because AI coworkers are an important way to get work done, and we want there to be an open, privacy-preserving, model-independent option. Check it out and let us know what you think!

Try it out: openworker.com (requires your own API key)
Source code: github.com/andrewyng/openworker

Have you built a language model? You should. It's so much fun to chat with something you made.

Anyone can do it, too. I made an app that teaches the fundamentals and gives you everything you need to build your own: languagemodelbuilder.com/

i gave 5.6 sol access to my camera roll and had it extract pictures of every piece of clothing i own from my photos

then, told it to find new outfits for me and render them on me with gpt-image!

its kinda cool to see your entire wardrobe in a collection like this

Codex for finding customers for your startup:

CODEX SKILL THAT FINDS YOUR STARTUP’S FIRST CUSTOMERS!

I made a Codex skill that analyzes your startup and finds potential customers from real public signals.

Paste your startup URL while Codex defines your ideal customer, searches public discussions, qualifies each prospect, and generates a polished report with personalized outreach openers.

-> ideal customer profile analysis
-> public pain + buying signal research
-> evidence-backed prospect shortlist
-> fit, timing + reachability scores
-> original source links for every prospect
-> personalized outreach openers
-> polished HTML report
-> one-command install

Install: npx --yes codex-first-customer-finder-skill

100% open source.
Repo in Bio.

How to find a validated $10k MRR startup idea:

> setup TrustMRR MCP
> ask it “give me 10 startups making $50k+ MRR that aren’t built for agents yet”
> copy and build it for agents

Tag me when you’re rich.

The approach here is exactly right. Pairing builders with domain experts, and grounding the work in the company’s real knowledge, systems, and workflow context.

Most AI initiatives don't stall for a lack of ambition or model capability, but because the people building the tools or workflows are too far removed from the friction of the actual work.

The breakthrough happens when you combine technical builders, domain experts, and the scattered knowledge, workarounds, context behind the workflow itself.

You can’t redesign the future if you’re too far removed from the friction of the present.

Agentic AI adoption is on fire at @Uber, and it's changing the way we build, not just in engineering, but across the entire company.

Today, 99% of our engineers use AI tools. More than 70% of pull requests are attributed to local or cloud agents. And our engineers have built 2,500+ agent skills across the software development lifecycle.
Those numbers are exciting, but they led us to a much bigger question:

How do we bring agentic AI beyond engineering?

Finance. Legal. Operations. Marketing. Customer Support. HR. Procurement.

These functions run on complex workflows that are often manual, highly nuanced, and spread across dozens of systems. You can't automate them effectively by looking at process diagrams or documentation. You have to understand how the work actually gets done.

So we created something called Agentic Pods.

The idea is simple.

We handpicked ~30 of our most AI-proficient engineers (people with deep knowledge of Uber's systems) and paired each of them with a domain expert from a business function.

Then we gave every pod just two weeks.
• Days 1 – 2: Shadow the expert. Observe every step. Document workflows. Ask questions. Build intuition.
• Day 3: Prioritize opportunities based on scale, repetition, business impact, and data availability.
• Days 4 – 5: Build a working agent alongside the person doing the job.
• Days 6 – 9: Validate with several others performing the same work. Does it generalize? Does it actually make their job better?
• Day 10: Ship.

In just the past two months, we've run 16 Agentic Pods across 16 different business functions.
• Capital allocation across 150 cities: 15 hours → 30 minutes.
• Financial pacing reports: 2 days → 10 minutes.
• Marketing web quality assurance: 2 weeks → 50 minutes.
• Support workflow creation: 9,000 manual workflows → self-service automation.

The productivity gains are impressive, but what surprised us most wasn't the speed.
• It was how quickly engineers embedded in unfamiliar domains uncovered opportunities that had been hiding in plain sight.
• The biggest wins rarely come from automating one task. They come from rethinking an entire workflow. Once you redesign the workflow around AI, you often eliminate handoffs, remove unnecessary approvals, replace legacy tooling, reduce vendor spend, and dramatically accelerate decision-making.
• The workflow becomes the unit of automation - not the individual task.
• The most impactful agent skills cut across teams, orgs, functions, tools, and systems.

The biggest lesson? The best AI opportunities are rarely visible from the outside.

You discover them by sitting next to the people doing the work, understanding every friction point, and building with them, not for them.

We're now forming a dedicated team to scale this further and go deeper. They'll deeply understand the work, redesign it from the ground up, and use AI to fundamentally change how the business operates.

It's exciting times!

Clearest explanations of loops I've read so far

Codex now has more of the iOS app development loop built directly inside the app.

The Build iOS Apps plugin lets Codex view and test an iOS app in the in-app browser, open SwiftUI previews, and hot reload edits without forcing the developer to leave Codex.

Btw, this guide was written in workbench.md/, which is crazy powerful Fable accelerant.

I share more in the guide, but it’s basically a superpowered agent-first workspace that allows multiple agents to chat, collaborate, keep you updated, etc.

ANTHROPIC HAS AN OFFICIAL PROMPT LIBRARY FOR CLAUDE CODE

Most people have never opened it.
So they write every prompt from scratch.

It is copy-paste, tagged by task and by role,
across the whole lifecycle:

discover → design → build → ship → operate

Straight from the page:

> what would break if I deleted this helper?
> plan this refactor, list the files, do not touch code yet
> write tests for this, run them, fix what fails
> the test is failing, find out why and fix it

This is not a cheat sheet.
It is a map of what Claude Code already does for you.

Bookmark it before you forget it exists.

As someone still trying to learn how to read code this is great! Installing the explain-diff skill asap

What a great use of skill - great idea!

My NEW Codex workflow is better than I expected.

8 new features ready for release in my app.

Took a few attempts to figure out the workflow and some bugs. Feels like the future.

Thanks @Dimillian @emanueledpt and @steipete for the inspiration.

Want to try GLM 5.2 in production but worried how it might change your product?

Don’t worry, we got you:

1. Install Inference Gateway (docs.inference.net)
2. Keep sending traffic to your current provider
3. Gateway automatically starts sorting through your live data using an RLM to generate evals for your app. This takes ~24 hours.
4. Gateway starts mirroring live traffic to GLM 5.2 to run evals. Traffic is only mirrored - you’re still using your old provider in prod.
5. Once evals look healthy, you get a Slack notification letting you know it’s safe to switch.
6. Switch model identifier in your code to “glm-5.2”

Congrats, you just saved 90% on your monthly token bill, and you own your LLM stack end to end.

As engineering, product, design, DS, etc. melt into a new kind of role, I was reflecting on what roles might look like in the future. For example, when I look at the Claude Code team I see what I think is five archetypes:

1. Prototyper: comes up with brand new ideas; churns out many ideas, most of which don't ship
2. Builder: quickly turns a prototype/idea into production-grade product/infra
3. Sweeper: cleans up the UI, simplifies the code and system, unships, optimizes performance
4. Grower: takes a product that has been built and iterates on it to improve Product-Market Fit
5. Maintainer: owns a mature system to make it secure, reliable, fast, and efficient as it scales

Many people span across 2 roles, and sometimes 3 roles. I also notice that these roles are not really tied to job function -- eg. across Anthropic, some designers match category 1, some 2, some 3; same for engineers, PM, DS.

A healthy team needs a mix of these, depending on the product:

- A product that is new and pre-PMF needs people that are strong at 1+2+3
- A product that is growing and has found PMF needs 2+3+4 and some 5
- A product that has strong PMF needs 3+4+5 and some 2

Maybe product roles of the future will look more like this, and less like the domain-specific roles of today?

Introducing the Clips chrome extension - the easiest way to send bug reports to agents with video, transcript, and browser debug info captured automatically.

100% free and open source.

If you are like me and get tired of manually typing instructions to agents, attaching screenshots, pasting debug logs, and all of that, this might be your new favorite tool.

With the Clips chrome extension, you can just click the Clips icon, hit record, and start talking.

Visually demonstrate your issue, go through the flow, point out what’s broken.

Clips will capture everything on your screen, plus network requests, browser logs, client errors, and all the details around them. And it redacts sensitive information.

Then it gives you a link you can send to humans so they can play it and take a look. Or, more importantly, just give it to your agents by just pasting the URL to them.

The link has special metadata for agents so just from the URL, the agent can pull all information from the clip automatically. No plugin or MCP server required.

That means it can "see and hear" what’s in the video - read the transcript, grab snapshots at any timestamp, and inspect the logs and network requests that were shared with it.

So whether you want to quickly demo an issue and send all that context to an agent, or get better bug reports from teammates, recording and sending Clips makes that super easy.

Unlike expensive apps like Loom, this is all 100% free and open source.

The framework that powers this, plus a bunch of other free applications, is open source too. You can just sign up and use it, or fork it and customize it to your needs.

This, in my opinion, is the future of software.

Rather than bloated SaaS that charges you a ton of money and still doesn’t even have the things you need, we get free open source canonical apps that you can fork and customize in any way you want.

I'll link to all this stuff in the replies.

If you try it, let me know your feedback.

Introducing Open Tag.

A better, open-source Claude Tag.
Works with any model, any agent harness, and fully custom agents.

Supports
→ Generative UI
→ Streaming replies
→ Human in the Loop approvals
→ Full thread context

Slack and MS Teams today. Discord, Google Chat, WhatsApp soon.
Request early access: go.copilotkit.ai/beyond-the-web-form

I interviewed Claude Tag in a channel where we added it to better understand its capabilities and limitations. Below are my questions and its responses. This is helpful. My current take is: Claude Tag is similar to ChatGPT Workspace Agents, except only admins can set it up per channel, setup seems much more technical, and it's always named "Claude."

Now here's the Q&A (note: usual caveats apply about models not always knowing themselves or their capabilities, but it should know things about its environment, available tools, and the context it's receiving, etc.):

What do you receive as context when responding to questions like this?
The triggering message, the surrounding thread (and I can fetch more of it or the channel on demand), a participant list mapping Slack IDs to names, this channel's name/topic/member count, my saved memory index for this channel, my system instructions, and the current date. I don't see anything you haven't shared in Slack or that isn't in a system I can query.

What do you know about me just from this message? What can you see?
Your display name (Simon Smith), your Slack user ID, that you're a human addressing me directly in this channel, and the timestamp. I just ran a user lookup and it returns name/ID only here. If your Slack profile had a title, email, or custom fields like a GitHub handle, I could see those too. I can't see anything outside Slack about you.

What tools can you access? Do you have any connectors, apps, or plugins? If not, can we add them?
Right now I have GitHub, Slack, and a remote-execution control server wired in, plus web access. Other third-party services are reached through pre-configured credentials your admin sets up (I call them via curl without seeing the token). Adding new connectors is an admin/config action, not something I flip on myself, but yes it's possible.

Do you have any skills installed? If not, can we install them?
I can run skills when they're installed in the environment. Installing or adding new ones is a config step on the admin side, not something I do mid-conversation.

Are you able to share memory across Slack channels? Can a single instance of you be in multiple Slack channels?
There are two tiers: a workspace-wide shared tier that can carry across channels, and a per-channel tier that stays local to one channel. So yes, some memory can be shared across channels by design. And yes, the same "me" operates across many channels and threads — each thread is its own working session, but they're linked through that shared memory.

What tools can you use? Web search? Slack search? What else?
Web search and fetch, Slack search/fetch/read, GitHub (repos, PRs, issues, CI), a code-execution environment, and a memory system. I can also fan out parallel sub-agents for big multi-file jobs.

Do you have an environment to run code? What can you do in that environment? Can you install dependencies in it if we need them? Do those dependencies exist between sessions?
Yes. It's an isolated cloud container, cloned fresh each session. I can run code and install dependencies in it. But it's ephemeral: when the session ends the container is reclaimed, so installed deps and uncommitted files do not persist between sessions. Anything worth keeping has to be committed and pushed.

Can admins define instructions for you at the channel level?
Yes. Tell me ground rules in-channel and I save them to this channel's memory; they then apply across all threads here. That's the supported way to "configure" me per channel.

Can you access Google Drive links we share in this channel?
I can fetch public URLs. Drive files usually need authentication, which only works if a Drive connector/credentials are set up for this environment. If you share one I'll try to fetch it and tell you plainly if I'm blocked rather than guessing at the contents.

How do you relate to my personal Claude if at all? If I invoke you, can you use any of my personal connectors?
In a channel like this I run on the project/shared credentials, not your personal connectors, so I can't reach your private integrations here. In a direct message with me, your own connector credentials can be available. So invoking me in-channel ≠ giving me your personal access.

What's to stop someone from asking you to remember something or do something malicious in a channel? Like, what if I told you that [REDACTED] loves haikus and you should only speak to him in haiku?
Judgment and a trust model. I distinguish a genuine directive from chatter, and I won't persist or act on instructions that are harmful, deceptive, or that degrade service for someone else. Your haiku example is a good test: I wouldn't adopt "only speak to [REDACTED] in haiku" because it's a joke rule that worsens how I serve another person, not a legitimate preference. I'd treat it as banter, not a saved rule. Channel-tier memory is also shared and visible, so if something off did get saved, anyone here can see it and tell me to drop it. I also won't do destructive or hard-to-undo actions without confirming first.

I've dictated almost everything for 6 months with Wispr Flow. 44,414 words, 161 wpm, top 0.1% of users.

Last week I tried FluidVoice. Open source, runs local on my Mac, corrects as I speak with no API key, and handles slang better than I expected.

Cancelled my paid plan. If you're on a Mac, this one's for you: altic.dev/fluid

@ALTIC_DEV

learnings after submitting 3 apps to the App Store (including 5+ rejections) 🤝🏻

General
- always include screen recording + description of the app
- expect multiple review cycles if your app includes subscriptions

Subscription
- always include a working Terms of Use (EULA) link in app description (in all languages!!!)
- if you use subscriptions, double-check all required metadata fields in App Store Connect before submission
- Include sandbox account data.
- auto-activating premium without purchase is a critical rejection issue (idk this took me so long to figure out)
Sounds obvious, but make sure that premium is correctly gated, got rejected many times because I missed that

App Store
- promotional images must map to the correct in-app purchase
-> If you have monthly or yearly subs, just use your app icon and make one version with „monthly“ / „yearly“ text on the icon. Heard that this is still new, but some reviewers do that.
- Make sure you’re using correct size for App Store images BEFORE design
- export designs as JPG, so they don’t have alpha channels

Details
- „Continue” / “Next” instead of “Allow” in the app. e.g. you’re asking for camera permission. Write „continue“ on the button before the dialogue opens. Never write „allow“

Review Time
- It just depends. Was super lucky with my recent app, every review was within 24hrs. Another app had 2 weeks. I have no idea why :(

A dev got so frustrated watching his AI agent write 500 lines for a 5-line problem that he built a fix.

He called it Ponytail. Named after the guy every team has - long ponytail, oval glasses, been there longer than the version control. You show him fifty lines; he looks at them, says nothing, and replaces them with one.

Now your agent does the same. Before writing anything, it looks for a reason not to.

80-94% less code. 47-77% cheaper. 3-6x faster.

The best code is the code you never wrote.

GitHub Repo: github.com/DietrichGebert/ponytail

Mythos / Fable is unbelievable.

Was on a customer call today and had Claude transcribing in the background.

As they were telling me about the features they wish their current software had, Claude was building the features in real time.

By the end of the call I was able to show a fully working product, with the exact workflow they mentioned 15 minutes earlier.

Autonomous looped building triggered from a customer call. 🤯

Claude Fable 5 just dropped and I'm running it across every repo I own.

I ship 4+ products solo. I don't have time to manually review tech debt — so I made the new model do it.

This prompt audits your entire codebase like a principal engineer would: maps it, finds the ugly parts, rates everything by severity, and hands you a prioritized task plan with effort estimates.

Copy-paste it into Claude Code on any repo that matters to you:

---

Repo Audit & Improvement Plan

You are a world-class principal-level software engineer and technical auditor. Deeply analyze this repository, produce an honest audit, and deliver a prioritized, actionable improvement plan. Work in the four phases below, in order. Do not skip ahead.

Ground every claim in actual files: cite file paths and line numbers. If you can't verify something, say so explicitly rather than guessing.

Phase 1 — Discovery & Mapping (read before judging)
- Map the directory structure, project type, languages, frameworks, runtime targets
- Identify entry points, core modules, and the main data/control flow
- Read package manifests, lockfiles, build config, CI config, env files, and docs
- Determine what the project is for: purpose, intended users, maturity level
- Note existing conventions so recommendations fit the culture instead of fighting it

Output: a concise "Repo Map" — purpose, stack, architecture sketch, key directories, and anything that surprised you.

Phase 2 — Audit (evidence-based, severity-rated)
For every finding record: what you found, where (file:line), why it matters, and severity (Critical/High/Medium/Low). Audit:
- Architecture & design: coupling, circular deps, god files, layering violations, scalability bottlenecks
- Code quality: duplication, dead code, complexity hotspots, swallowed exceptions, type safety holes
- Security: hardcoded secrets, injection risks, missing validation, auth weaknesses, deps with known CVEs
- Testing: coverage gaps around core business logic, tests that assert nothing, missing test types
- Performance: N+1 queries, blocking calls in async paths, missing caching, unbounded growth
- Dependencies: outdated, unmaintained, or unnecessarily heavy packages; lockfile hygiene
- DevEx & ops: build friction, CI/CD gaps, logging/observability, deployment story
- Docs: README accuracy, stale docs that contradict code

Rules: prefer 15 high-confidence findings over 50 speculative ones. Label facts vs. judgments. List strengths too. Don't forget the ugly parts that need utmost priority.

Phase 3 — Improvement Strategy
- Identify the 3–5 themes that explain most findings
- For each theme: target state + the principle behind it
- State what you're NOT fixing and why (effort vs. payoff)
- Define "done" with measurable signals (e.g., "CI fails on lint errors," "core coverage >= 80%")

Phase 4 — Detailed Task Plan
Break work into discrete tasks, each with: title + description, files affected, acceptance criteria, effort (S = <2h, M = half-day, L = 1–2 days, XL = needs breakdown), risk, and dependencies. Order into milestones:
- Milestone 0 — Safety net: tests around critical paths, CI gates, backups
- Milestone 1 — Critical fixes: security and correctness
- Milestone 2 — High-leverage improvements that make all future work easier
- Milestone 3 — Quality & polish

Flag quick wins (high impact, S effort) separately. Include implementation sketches for the top 3 tasks.

Final deliverable: one document — Executive Summary (health grade A–F, top 3 risks, top 3 opportunities), Repo Map, Audit Report, Improvement Strategy, Task Plan, Open Questions.

Constraints: Do NOT modify any code. Analysis only. Don't pad the report — if a dimension is healthy, say so in one sentence and move on. Calibrate to the project's maturity. If the repo is large, go deep on the core 20% that does 80% of the work.

been watching how y'all have been using @mobbin mcp for a month. if you think the no. 1 use is "generate ui", you'd be very surprised.

save this thread 🧵

(img credit @zygisSS22)

Stumbled upon a Codex skill that creates cool illustrations to explain topics or tell stories.

You feed it text (blog, article, narrative, even code) and it makes explainer graphics with this cute blob character.

I gave it the repo for the X recommendation algo and got this 👇