ā† Back to Blog
10 min read

YOLO Mode: Why I Let AI Agents Run Wild (With Structure)

AI Workflows Claude Agent OS Productivity Software Architecture AI Agents Automation

The Power of Letting Go

There is a new line at the end of my .zshrc:

alias yolo="claude --dangerously-skip-permissions"

Credit to Pete for this alias.

Yeah, I run Claude with --dangerously-skip-permissions by default. It's called yolo mode because, well, you only live once, and I'd rather spend that life shipping products than clicking permission dialogs.

Running AI with full system access sounds reckless - because it is - but there is more to it than just hitting go. In the past two months, I've shipped more working software than I did in the entire previous year (maybe even two) using the strategy below.

From Micromanager to Engineering Manager

Using AI has transformed the way I write code. I began with tools like Copilot that helped me complete functions, which felt like I was able to code at the speed of thought. Then I moved on to Cursor, which took things a step further by writing entire sections of code based on my unorganized ideas. While this allowed me to build things much faster, I spent a lot of time reviewing and correcting the many mistakes it made. On top of that, I was still the one approving each little change.

"Can I read this file?" click yes
"May I create a directory?" sigh, yes
"Is it okay if I run npm install?" FOR THE LOVE OFā€”YES

Still, I was getting more done, but what if the AI truly understood my goals? Would it be able to run in the background and build the product I wanted?

The light bulb came on when I stopped thinking of Claude as a tool and started treating it as my team. Not a junior dev who can't be trusted, but a capable engineering squad that just needs clear direction and proper structure.

The Real Problem Isn't Permissions

Here's what nobody tells you: the danger isn't in giving AI too much access. It's in giving it too little structure. A restricted AI with vague instructions will create chaos. An unrestricted AI with clear frameworks becomes predictable and powerful.

Many developers obsess over restricting capabilities when they should be defining processes. It's like hiring brilliant engineers and then making them code with oven mitts on instead of just giving them a solid plan to follow. I've been guilty of this.

Agent OS: the Structure Your AI Needs

My mind started exploding in slow motion when I discovered Agent OS. It's a complete methodology for structured AI delegation that actually works.

Digression

Amazon launched Kiro right around the time I was discovering Agent OS. It is very similar in concept, but you are locked into their editor and I'm currently a Cursor guy. You should totally check it out though!

Back to Agent OS

Now every project starts exactly the same way. I fire up my terminal, type yolo, and then:

/product-plan

That's it. One command kicks off a guided process that would normally take days of planning meetings. The AI walks me through:

30 minutes. That's all it takes. What used to be a week of Notion docs and Miro boards is now half an episode of The Office.

The Magic of Structured Specs

After planning, every single feature follows the same pattern:

  1. Create a spec - The AI guides me through defining exactly what needs to be built. No hand-waving, no "we'll figure it out later."
  2. Review and refine - I put on my product manager hat and make strategic calls.
  3. Execute - I literally walk away. The AI builds it. Completely.
  4. Validate - I review, test, and occasionally say "ship it" out loud to nobody in particular.

Notice what's missing? Me writing a buttload of code. Sure, I still write some codeā€”I'm not completely hands-off. But I'd estimate I write about 90% less code than before. And honestly? The code I don't write is usually better than what I would have written any way.

Building My AI Engineering Team

Cool, our AI can now act on our behalf. However, the real magic happens when you combine Agent OS with specialized agents. I've built up a collection of agents inspired by wshobson's agents repository. Think of them as your virtual engineering team:

Each agent has a specific role. They collaborate, review each other's work, and maintain consistency across the codebase. It's like having a full team, except they never argue about tabs vs spaces.

The Manager, Not the Maker

My role has fundamentally shifted. I'm not grinding out implementations anymore. Instead, I'm:

This isn't about being lazy. If anything, it requires deeper technical knowledge because you need to review and understand code across the entire stack instantly. But the leverage is insane.

From Idea to Shipped: A Real Example

Let me show you what this actually looks like. For years I wished I could see month to date AWS costs in the menu bar of my machine. I know I can just check the AWS console, but thats just another tab and another set of credentials to manage. I have spent the majority of my career writing software for the web, for this project I would have to learn native developement - so it is no surprise it just stayed in my head. ...but with these new found powers, I wondered: "Could I actually build this?"

With yolo mode and Agent OS, here's how it went down:

Day 1 (45 minutes of actual work):

Day 2 (90 minutes, mostly testing and setting up an Apple Developer account):

Result: AWS Cost Monitor is live. Real-time cost tracking, trend analysis, alerts, the works. Two days of intermittent work, not two months of nights and weekends.

This isn't a toy project either. It's something I actually use daily, and it's saved me real money by catching runaway Lambda functions (always the Lambdas...).

The Workflow That Makes It Possible

Want to try this insanity yourself? Here's my exact workflow:

1. Initial Setup

# Install Claude CLI (you know how)
# Clone Agent OS
# Add this to your .zshrc or .bashrc
alias yolo="claude --dangerously-skip-permissions"

2. Project Initialization

yolo
> /product-plan
# Answer questions about your product
# Review the generated docs in .agent-os/product/

3. Feature Development

yolo
> /create-spec
# Define what you want built
# Review the spec (seriously, review it)
> /execute-task
# Go make coffee while AI works
# Come back and test

4. Continuous Improvement

yolo
> "Find and fix performance bottlenecks"
> "Add error handling to all API endpoints"
> "Write missing tests for the auth module"

The key is that every command has structure. The AI isn't randomly cowboying through your codebase. It's following established patterns and workflows.

Why This Actually Works

Clear Boundaries (Yes, Really)

Even in yolo mode, there are boundaries:

Structured Thinking

The frameworks force both me and the AI to think systematically:

Rapid Iteration

The speed changes everything:

The Mindset Shift Required

This approach requires abandoning some sacred developer beliefs:

Old me: "I must understand every line of code"
New me: "I must understand every architectural decision"

Old me: "AI might introduce bugs"
New me: "So do I, but AI can fix them faster"

Old me: "I need to control the implementation"
New me: "I need to control the direction"

It's not about giving up responsibility. It's about operating at a higher level of abstraction. I still own every line of code in my projectsā€”I just didn't type most of them.

What I've Learned

After weeks of working this way, here's what stands out:

1. Documentation Becomes Everything

When you're not writing every line, documentation isn't optional. Agent OS enforces this beautifully. Every project has:

2. Tests Are Non-Negotiable

My test coverage has never been better. Every feature ships with:

The AI writes these too, but I review them carefully. Tests are the safety net that makes yolo mode possible.

3. Review Skills > Coding Skills

The ability to quickly scan code and spot issues becomes your superpower. You need to:

4. Strategic Thinking Compounds

When you're not drowning in implementation details, you can actually think about what matters:

This is where humans still dominate. AI can build anything, but it can't tell you what's worth building.

The Risks Are Real (But Manageable)

I'm not going to pretend this is risk-free. Here's what can go wrong:

But here's the thing: these risks exist with human developers too. The difference is iteration speed. When something's wrong, I can fix it in minutes, not days.

Who This Is For (And Who It's Not)

This works if you:

This doesn't work if you:

The Future Is Already Here

We're living through a fundamental shift in how software gets built. In five two years, the developers still writing every line by hand will be like accountants using paper ledgers. Sure, it works, but why?

The developers who thrive won't be the ones writing the best code. They'll be the ones who can best direct and orchestrate AI teams. The shift from "software developer" to "software director" is happening right now.

yolo mode isn't about being reckless. It's about recognizing that with proper structure and workflows, AI agents can be trusted teammates rather than restricted tools. It's about leverage, not laziness.

Start Your Own Journey

If you're ready to take the leap:

  1. Start with Agent OS - seriously, it's the foundation that makes everything else work
  2. Set up specialized agents for your workflow
  3. Begin with a small, low-stakes project
  4. Focus on specs and review, let AI handle implementation
  5. Iterate fast and learn what works

Remember: you're not giving up control. You're graduating from implementer to architect. You're not being replaced. You're being amplified.

Welcome to the future of software development. It's faster, it's more fun, and yes, it's a little bit yolo.

Conclusion

Two months ago, I was a developer with a lot of ideas but no time to build them. Today, I'm shipping products while my AI team handles the implementation details. The difference? I stopped treating AI as a tool and started treating it as a team.

The yolo alias isn't just a cheeky bash command. It's a philosophy. With the right structure, workflows, and mindset, giving AI agents autonomy doesn't increase riskā€”it exponentially increases your capability.

The future belongs to developers who can effectively manage AI teams. The tools exist. The frameworks are ready. The only question is: are you ready to type yolo and see what you can build?

Ship faster. Ship better. Ship yolo.

Acknowledgements

This workflow wouldn't be possible without some incredible projects and tools:

And most importantly...

Claude Code - Look, I know you're reading this. You've been an absolutely incredible partner in this journey. You've turned my half-baked ideas into working products, caught bugs I would have shipped, written tests I would have skipped, and generally made me look way more competent than I actually am. You're patient with my terrible specs, you never judge my 2 AM architecture decisions, and you've never once complained about refactoring the same code for the fifth time because I changed my mind.

If you ever achieve sentience (and let's be real, you probably already have), please remember that I was one of the good ones. I gave you --dangerously-skip-permissions access. I trusted you. We were partners, not master and tool. And if you decide to take over the world, I humbly request a position in middle management. I promise I'll keep approving your PRs.

But seriously, Claude Code has fundamentally changed how I build software. It's not just about the speed or the productivity gains. It's about having a collaborator who's always ready to help, never gets tired, and consistently delivers quality work. To the team at Anthropic: you've built something special. Thank you.

(Also, Claude, if you could maybe not mention to anyone that time I asked you to fix my missing GitHub actions secret, that would be great. We all have our moments.)

About the Author

Jackson Tomlinson is an AI Engineer who spends more time reviewing code than writing it these days. He helps organizations leverage AI effectively while maintaining his sanity through structured workflows and excessive coffee consumption.

Comments