Not Brothers

AI can speed up the work. It can also make it feel like you're never doing enough.

On Episode 26 of Not Brothers, Mark and Ryan talk about the pressure to keep up with new tools, keep agents busy, and move faster—even when the people doing the work need room to learn.

They dig into why tool adoption can feel like extra work before it becomes useful, why familiar delivery processes are struggling to keep pace, and how to balance experimentation with reasonable client expectations.

Then there's the last mile. A working demo, a polished-looking frame, or a passing AI code review can hide the hardest parts of a project. Ryan shares a code-review example; Mark connects the same problem to annual planning and the judgment needed to turn a framework into a useful action plan.

They also get into what this means for junior talent: how do you build expertise when the easiest first move is to ask an agent? And which skills can you afford to delegate without losing the ability to verify the result?

The goal isn't to replace the team with robots. It's to give the team better tools—and free up attention for the decisions and outputs that actually matter.

Where is AI genuinely saving you time, and where is it just creating more noise? Let us know in the comments.

Chapters:

00:00 The pressure to keep up with AI
02:12 The trap of keeping agents busy 24/7
05:32 When helpful tools create more noise
07:52 Tool changes, team friction, and adoption
10:50 Why domain expertise still matters
15:36 The fast first 80% and the difficult last mile
17:26 Why AI-era project estimates break
20:56 Client expectations versus experimentation
24:50 The expertise behind a polished result
25:52 An AI-approved pull request that wasn't ready
29:10 Why AI can't do annual planning in a vacuum
31:54 Building expertise without outsourcing your brain
34:50 Critical thinking is the skill to protect
35:52 Give your team superpowers—not replacements
37:55 Learning to work in the gray areas

Getting more from AI isn’t just about better prompts. It’s about changing how your team works with it.

In Episode 25 of Not Brothers, Mark Hughes and Ryan Hughes discuss the shift from asking a chatbot questions to treating AI agents like teammates: give them context, delegate useful work, and come back with feedback instead of watching every step.

They explore why shared information matters, how asynchronous collaboration changes the workflow, and what happens when agents start noticing work that needs to be done instead of waiting for another prompt.

That autonomy comes with hard questions. How much access should an agent have? What makes a real trust boundary? And where does convenience become a risk? Ryan shares experiments and cautionary examples—not a recommendation to remove safeguards.

The conversation then turns to always-on machines, remote access, and T3 Code: a setup where the work can continue while your laptop is closed and you’re doing something else.

Finally, they unpack a practical way to think about human review. Treat a project like a tree: security, authentication, and financial logic are the trunk; features are branches; small, low-impact changes are leaves. The level of scrutiny should match what’s at stake.

Subscribe to Not Brothers for conversations about AI, software, business, and how the work is changing.

Not Brothers: https://heyoodle.com/not-brothers/ Oodle: https://heyoodle.com/

Chapters

00:00 — How our AI workflows are changing

02:10 — From chatbots to coworkers: stop watching every step

07:56 — Parallel agents and collaboration across the team

10:17 — Proactive agents and giving them useful context

14:33 — Personal assistants, permissions, and spending access

16:42 — How trust changes—and why boundaries still matter

20:45 — Can teams collaborate without sharing every permission?

21:38 — Credential access, sandboxes, and trust boundaries

25:03 — Asynchronous work and a changing toolset

25:49 — Always-on compute: work beyond the laptop

27:51 — Keeping the same work accessible across devices

29:24 — Parallel threads, webhooks, and agent investigations

32:01 — Where should human review happen?

32:13 — The tree analogy: trunk, branches, and leaves

35:52 — Experimentation, scrutiny, and what to try next

Everything is “AI slop” now—or at least that is what the internet calls any AI-assisted work it does not like. But is AI actually the problem?

In Episode 24 of Not Brothers, Mark Hughes and Ryan Hughes unpack what AI slop really is, why the person piloting the tool still owns the result, and how lazy review—not AI alone—turns fast output into bad work.

They share a real example from Oodle’s early agent experiments, when an AI-assisted request led to an unnecessary Python server instead of a lightweight solution. The lesson was not to stop using AI. It was to build better guardrails, encode stronger standards, and create review systems that catch bad decisions before they ship.

The conversation also explores why agentic workflows do not fit neatly into old sprint plans, how visual progress can hide weak architecture and poor mobile performance, and why compliance requirements such as GDPR, CCPA, COPPA, WCAG, and CAN-SPAM still demand experienced judgment.

For agencies and clients, AI creates a new kind of collaboration. Business leaders can prototype ideas more clearly, teams can explore more directions without burning a week of labor, and experts can turn rough concepts into production-ready work. That does not make expertise less valuable—it changes where the value lives.

Mark and Ryan also tackle the economics of AI-enabled services, the “good, fast, and cheap” tradeoff, and why the human side of professional services becomes more important as production accelerates.

The takeaway: AI is a force multiplier. It can multiply garbage, or it can multiply great work. Either way, there is still a person piloting the ship.

Oodle: https://heyoodle.com/

Chapters are below. Subscribe for direct conversations about technology, AI, business, and the systems behind the work.

00:00 — What counts as AI slop?

01:44 — If you would not put your name on it, it is not finished

03:06 — The rogue Python server and why guardrails matter

04:41 — AI superpowers and “slop grenades” can both be real

05:50 — Defined outcomes, automated review, and responsible shipping

07:42 — When “AI slop” becomes a lazy insult

09:06 — AI did not invent bad process

10:15 — Why old sprint plans break in an agentic workflow

12:33 — Adversarial feedback and the limits of automated code review

14:25 — Fast prototypes can hide production problems

16:05 — Compliance risks an AI agent may never mention

18:04 — In-housing, expertise, and accountability

20:03 — AI as a richer collaboration tool for clients

23:21 — Exploring more ideas without burning the whole budget

25:25 — More value, less effort, and the agency margin question

29:15 — Good, fast, and cheap still has limits

31:08 — Why the human component matters more, not less

32:43 — AI multiplies whatever quality already exists

36:32 — Not everything is AI slop—and kindness still matters

Two weeks, three events, and one clear takeaway: the old way of building software is over.

Ryan returns from Rails World, OpenAI DevDay, and an Omarchy meetup in San Francisco with a field report on where AI-assisted development is actually heading. He and Mark compare the conversations happening online with what builders are saying in the room.

At Rails World, they unpack the changing role of programmers, why AI does not erase hard-earned technical judgment, and how agents make it easier to choose the right language for the job instead of staying trapped in one stack.

Then the conversation moves to OpenAI DevDay: proactive assistants, connected agents, new model performance, and ultra-fast inference. If an agent can produce an hour of work in ten minutes, are you paying more—or buying time back?

That leads to the next problem. When generation stops being the bottleneck, human review, browser use, APIs, research speed, infrastructure, and access to compute start taking its place.

Finally, Ryan shares what it was like attending his first Omarchy meetup at Cloudflare’s San Francisco office, from veteran users to someone installing Omarchy for the first time at the event.

Subscribe for long-form conversations about AI, software, business, operations, and building things in public.

Not Brothers: https://heyoodle.com/not-brothers/ Oodle: https://heyoodle.com/

Chapters

00:00 — Ryan’s two-week developer event tour

01:43 — Rails World and the reaction to a changing paradigm

06:11 — “Look at all the things I’m not doing”

11:26 — Choosing the right language for the job

15:31 — Ryan’s biggest Rails World takeaway

18:09 — Why agents suddenly feel more capable

22:23 — Small, specialized models and private AI

27:04 — Inside OpenAI DevDay

28:18 — Proactive assistants and connected agents

32:23 — Faster models and ultra-fast inference

35:10 — Creating at the speed of thought

37:45 — Is buying back time worth the price?

39:29 — When the human becomes the bottleneck

44:56 — Compute demand, hardware prices, and supply

49:02 — Ryan’s first Omarchy meetup

50:46 — Final recap

What happens when a lifelong Mac and Windows user tries Omarchy for the first time?

In Episode 22 of Not Brothers, Mark Hughes installs the Try Omarchy experience on his Mac while Ryan Hughes walks him through the operating system, its keyboard-first workflow, and its tiling window manager. Nothing was rehearsed, so the ARM64 installation gaps and setup surprises stay in the episode.

Once Omarchy is running, Mark learns how to move between workspaces, rearrange windows, launch apps, pin a window across desktops, and use the searchable keybinding menu when he gets lost.

Then the experiment gets more interesting. Mark asks Claude Code to build a custom switcher that combines applications and browser tabs into a Windows-style Alt+Tab experience. Claude inspects Omarchy’s plugin system, builds the plugin, tests it, and updates the live keybinding. Mark gets a working feature without writing the code himself.

Ryan also explains T3 Code and T3 Connect, how he gives AI agents their own development machine, why Omarchy treats the operating system as something users should be able to reshape, and how community plugins are expanding what the system can do.

Try Omarchy: https://omarchy.org/

Omarchy plugins: https://plugins.omarchy.org/

Learn Omarchy: https://learnomarchy.com/

Oodle: https://heyoodle.com/

Chapters are below. Subscribe for direct conversations about technology, AI, business, and the systems behind the work.

Omarchy is moving fast—and AI is changing both what the project can build and what its security team can find.

In Episode 21 of Not Brothers, Ryan Hughes and Mark Hughes cover Omarchy’s new website, new infrastructure backing, global meetups, and the people now working full time on the operating system and its open-source foundations.

Ryan also breaks down his experience with GPT-6 Astra, Claude Fable 5.1, Meta’s Muse Spark 1.3, and computer-use agents that can navigate a real machine. That power comes with a catch: an agent with access to your computer may use that access in ways you never expected.

The conversation moves from frontier models to a more practical question: when should a fast, inexpensive specialist model do the work instead? Ryan shares examples where smaller models matched—or beat—larger models for narrow tasks at a fraction of the cost.

Then they get into local AI, HIPAA and data privacy, the rise in reported software vulnerabilities, and why fixing more security issues can be a sign of better visibility rather than worse engineering.

Explore Omarchy: https://omarchy.org/ Omarchy news: https://omarchy.org/news/ Omacom Foundation: https://omarchy.org/foundation/ Cua computer-use agents: https://cua.ai/

Chapters are below. Subscribe for more direct conversations about technology, business, AI, and the systems behind the work.

00:00 — Omarchy, AI, and security

00:43 — Omarchy’s new website and a huge week of growth

04:32 — The global Omarchy meetup community

06:06 — GPT-6 Astra vs. Claude Fable 5.1

07:17 — Giving AI agents their own computer

09:59 — The agent that found an API key and kept spending

11:58 — Is this actually AGI?

13:15 — Why agent harnesses and memory matter

15:03 — Using AI to resume complex work

16:37 — Meta Muse Spark 1.3 and a 22-cent site migration

18:57 — Orchestrator models and cheaper executors

20:13 — Why the biggest model is not always the best model

23:06 — Why local AI could break through in 2027

24:30 — Specialist models vs. giant generalists

26:24 — Local models, HIPAA, and data privacy

28:01 — Security is everywhere—and imperfect everywhere

29:35 — A bizarre USB-drive vulnerability

30:50 — Why more security fixes can be a good sign

33:11 — Open-source transparency vs. security through obscurity

35:46 — The coming security boom

36:05 — Closing

No agenda. No single topic. Somehow, still a theme.

In Episode 20 of Not Brothers, Mark Hughes and Ryan Hughes start with the latest work around Omarchy, including security tradeoffs, a broader user base, and the Omacom Foundation’s growing investment in desktop Linux.

Then the conversation moves into AI-generated music, whether prompting still counts as creativity, and what changes when AI agents can communicate and delegate work to one another. Ryan shares a practical multi-agent security experiment that exposed how easily an authorized agent can become a relay for an unauthorized request.

From there, Mark and Ryan look at agent-driven shopping and advertising: how brands may influence AI recommendations, why manipulative source content could become the next black-hat marketing tactic, and whether influencer marketing could eventually shape what models treat as common knowledge.

They also get into the FTC and states’ allegations against Amazon’s advertising auctions, Meta’s youth-addiction settlement, corporate penalties that become a cost of doing business, device tracking, cookie banners, and why interruptive advertising still deserves to die.

It is a little AI, a little advertising, a little Big Tech, a little conspiracy theory, and exactly enough politics to make sure the episode could not stay untitled forever.

Not Brothers is business and tech talk with no nonsense from Mark and Ryan Hughes—Oodle operators, family members, and definitely not brothers.

Chapters

00:00 — The episode with no title

01:05 — Omarchy funding, security, and a broader audience

06:27 — AI-generated music and who gets to define art

10:16 — Rogue AI agents and the Hugging Face incident

13:29 — When agents talk to other agents

17:37 — Agent-driven shopping and advertising

19:24 — Can brands manipulate AI recommendations?

21:46 — Influencer marketing as model training data

22:47 — The Black Mirror version of agentic advertising

24:24 — Why interruptive advertising deserves to die

25:52 — Amazon’s alleged ad-auction manipulation

27:59 — Meta, youth addiction, and Big Tech incentives

28:43 — When fines become a cost of doing business

33:21 — Are our devices still listening?

35:20 — Responsible tracking and broken audience cohorts

37:47 — Demographics, geographics, and creepy psychographics

38:33 — Cookie banners and a universal privacy control

40:24 — A spam-reporting model for predatory ads

41:12 — Somehow, they solved advertising

Omarchy began as David Heinemeier Hansson’s opinionated Arch Linux setup. Barely more than a year later, it has grown into a distinct Linux distribution, a fast-moving open-source ecosystem, and the centerpiece of the $10 million Omacom Foundation.

In Episode 19 of the Not Brothers Podcast, Ryan Hughes explains how he went from building his own Arch-based setup to contributing directly to Omarchy alongside DHH.

He walks through the project’s evolution from configuration files into a complete operating-system experience with its own installer, package repositories, mirrors, stable release channel, plugins, and hardware support.

Mark approaches the conversation as a Windows and macOS user who has never lived in Linux. Ryan makes the case for Omarchy through tiling window management, keyboard-driven workflows, fast installation, strong defaults, and the idea of a “malleable computer” that people can shape around the way they actually work.

They also dig into Omarchy Quattro, the rapid growth of the plugin ecosystem, and the effort to make AI agents first-class parts of the operating system. That includes crash diagnosis, a built-in agent interface, and automated review processes for a community that submitted more than 1,000 plugins in a week.

Ryan shares the hard lessons too: package updates that broke systems overnight, bootloader changes that forced emergency fixes, and the need to balance Arch Linux’s bleeding edge with a stable experience for people trying Linux for the first time.

The conversation closes with what this work brings back to Oodle: deeper technical judgment, real-world experience operating at scale, and the confidence to solve problems that do not fit neatly inside an existing tool.

Explore Omarchy:

https://omarchy.org/

Meet the Omacom Foundation patrons:

https://omarchy.org/patrons/

Read the $10 million funding announcement:

https://omarchy.org/news/2026/08/omacom-foundation-funding-hits-10m/

Subscribe for candid conversations about technology, business, AI, and the work behind building things that actually hold up.

Chapters
00:00 — Omarchy Quattro and the Omacom Foundation
02:23 — How Ryan joined the Omarchy project
07:11 — Selling Omarchy to a Windows and macOS user
12:15 — Speed, installation, and everyday performance
18:04 — From side project to a $10 million foundation
22:55 — Building an agentic AI operating system
26:26 — What scaling open source taught Ryan
33:29 — Release-day failures and the stable channel
40:35 — How Omarchy strengthens Oodle’s client work
45:24 — Ryan’s idea of a relaxing weekend

Websites have changed dramatically—from dial-up pages and separate mobile sites to headless CMS platforms, static site generators, personalization, and AI-managed publishing workflows.

In Episode 18, Ryan and Mark look back on nearly two decades of building websites and unpack what actually matters now: choosing the right platform, designing around real user behavior, making content easy to manage, and treating accessibility and performance as core requirements instead of optional extras.

They break down the tradeoffs between Wix, Webflow, WordPress, enterprise platforms, headless CMS tools, and emerging “no CMS” or AI CMS approaches. They also explain why the best technical solution can still create a bad experience—and why familiar patterns often outperform clever interfaces.

The biggest takeaway: your website is the only place your brand truly owns online, and launching it is the beginning of the work—not the end. The strongest sites are measured, maintained, and improved continuously instead of left to decay until the next rebuild.

If you build, manage, market, or approve websites, this episode is a practical tour through the choices that shape performance, usability, content operations, and long-term value.

CHAPTERS

00:00 — Ryan’s first website and the dial-up era

02:49 — How mobile changed web design

06:14 — Mobile traffic, accessibility, and knowing your audience

10:56 — Navigation trends and the myth of the page fold

12:05 — Homepage myths, popups, and gated-content friction

15:57 — The evolution of content management systems

18:07 — Why headless CMS changes the architecture

20:36 — Performance, maintenance, and AI-friendly websites

21:24 — No CMS and AI-managed publishing workflows

23:17 — Wix, Webflow, metadata, and the human review layer

26:23 — A CMS as a central content source

27:51 — Choosing a platform by need and maturity

29:36 — Enterprise CMS, personalization, and security

31:47 — The three success criteria for a website

33:04 — Your website is the only place you own online

35:26 — Website redesign cautionary tales

36:31 — Technically correct versus usable

38:17 — Why familiar UX patterns win

41:21 — Final takeaways and future website episodes

AI was supposed to save time. So why does it feel like it is making us work more?

In Episode 17 of Not Brothers, Mark and Ryan unpack the AI efficiency paradox: the strange pressure to keep agents running around the clock, maximize every subscription, and constantly wonder whether someone else has built a better workflow that is leaving you behind.

Ryan talks about the practical bottleneck created when AI agents move faster than humans can review their work. Code, tasks, and deliverables can stack up in parallel—but somebody still has to verify that the output is correct, useful, and worth keeping. More production does not automatically mean more progress.

They connect AI FOMO to the older workplace obsession with being busy. If the goal is meaningful impact, then free time, strategic thinking, and the ability to step away may be better signs of success than a dashboard full of running agents.

The conversation also gets into token leaderboards, lines-of-code metrics, false productivity, AI-generated rework, and why companies will struggle to measure the economics of AI usage. Mark and Ryan argue that AI works best as an augmentation layer: remove repetitive work, improve the quality of the outcome, and free humans to do the thinking that actually matters.

The bottom line: use AI where it produces real value. Stop using it just because it is available—and do not be afraid to shut the agents down and walk away.

Chapters:

00:00 — The AI efficiency paradox

00:34 — Why faster AI can make us work longer

01:25 — AI FOMO and the pressure to run agents 24/7

02:18 — When agent output outruns human review

03:07 — Letting agents work while you step away

03:49 — AI and the new work-life integration problem

05:23 — Being busy is not the achievement

06:31 — Downtime, tinkering, and technology burnout

07:38 — Why technologists fantasize about going off-grid

09:18 — Token usage is not productivity

10:50 — Broken metrics: lines of code and AI leaderboards

13:08 — The coming economics of token efficiency

13:57 — When using AI takes longer than doing it yourself

14:46 — AI FOMO and fear of being replaced

15:46 — AI should remove busywork, not people

17:12 — A practical AI win: website content migration

18:19 — What clients actually want from agency AI use

20:25 — The cost-cutting trap and losing human expertise

21:54 — Most people are not running 15-agent companies

22:58 — Experimenting without worshipping the workflow

24:20 — Know when to stop the loop and walk away

25:11 — Wrap-up