How to Make Claude Code Better Every Time You Use It | Kieran Klaassen

Summary

Podcast Summary: Behind the Craft

Episode: How to Make Claude Code Better Every Time You Use It | Kieran Klaassen
Date: February 8, 2026
Host: Peter Yang
Guest: Kieran Klaassen, CTO at Quora (every), builder of the Compound Engineering method and plugin

---

Overview

This episode dives deep into how to make AI coding tools—specifically Claude Code—more effective every time you use them. Kieran Klaassen, CTO at Quora (every), shares his "Compound Engineering" philosophy and toolkit, revealing strategies and hands-on tactics for building compounding systems where your AI code agent learns, adapts, and gets better with every feedback loop. Kieran gives a live tour of his exact workflows, plugins, and principles that put an AI-powered, multi-agent developer environment within reach of all modern product builders.

---

Key Topics and Insights

The Philosophy of Compound Engineering

• AI's continual learning: Kieran emphasizes that AI can and should learn from every mistake and every bit of user feedback to improve continuously.
  • "If you invest time to have the AI learn what you like and learn what it does wrong, it won't do it the next time." (Kieran, 00:00)
• The Compound Loop: The process is a four-stage loop:
  1. Planning: Laying out a work plan.
  2. Working: Executing the plan.
  3. Assessing/Reviewing: Checking the work for correctness, coverage, and quality.
  4. Codifying Learnings: Capturing feedback as explicit, reusable knowledge—so next time, the AI doesn't repeat mistakes.
     • “Making sure those learnings are captured. And then the next time you create a plan, it's there, it learns. So that's really the philosophy of the loop.” (Kieran, 01:54)
• Compound Engineering is also available as an open-source plugin that anyone can install.

[01:54-03:33]

---

Practical Walkthrough: Setting Up and Using Compound Engineering with Claude Code

Environment and Initial Setup

• Terminal & Tools: Kieran uses Warp (an AI-based terminal) and runs Claude Code in dangerous skip permissions mode.
• Project Example: Making the Quora app "Agent Native"—letting the in-app AI do anything a user can.
  • “The idea of Agent Native is that the assistant…the agent within the app can do exactly the same thing as the user can.” (Kieran, 03:34)

Detailed Steps Within the Loop

1. Planning Phase

• Enhanced AI Planning:
  • Uses multiple sub-agents that analyze existing code, research best practices, and explore the frameworks and versions used.
  • Heavy use of context and tokens to ground the plan in real project data.
  • Sub-agents run in separate contexts for maximum specialization.
    • “It will use more tokens, but also it will do better research…it grounds itself in what you already did... it will pick up those patterns…” (Kieran, 07:34)
• Skills and Agent-Native Skills:
  • Define reusable “skills” and knowledge that the AI can pull in when relevant.
  • “A skill is this way, like it's kind of just-in-time context... You can create your own skills that you reference.” (Kieran, 12:54)

2. Deepening, Reviewing, and Refining Plans

• Iterative Refinement:
  • Kieran recommends reviewing draft plans, and encouraging the AI to generalize tooling or consolidate steps.
    • “Can we not somehow consolidate this?... Can we create one tool that can do multiple settings so it's less heavy?” (Kieran, 20:00)
  • If a new learning is discovered, use the compound flow to ensure next plans don’t repeat past mistakes.
    • “I'm going to run the compound flow and it will understand from the context here what it is about…so next time when it starts writing a plan, it will pull in that information…” (Kieran, 20:00)

3. Working / Execution

• Launching the Work: Paste the improved plan and let Claude code execute it.
• Context Management: Optionally start a new session for a clean context.

4. Assessment / QA Review Loop

• Testing with Playwright:

  • Automated end-to-end browser tests (including video/screenshot capture) using Playwright, orchestrated by Claude.
    • "You don't even need to write a test…it's a QA team, basically...And the beauty is it is in Claude code, so if something breaks, it can fix it immediately and immediately validate whether it fixed it." (Kieran, 33:10)
  • Real use-case: Even crazier integration flows, like live-testing Gmail integrations.
    • “With Playwright, I could just log in with my Gmail account and say, hey, I'm logged in…Just see if it works. And it went to Gmail. It's just a browser.” (Kieran, 34:05)

• Multiple Specialized Reviewers:

  • Custom AI reviewers: security, architecture, simplicity, “agent-nativeness,” and more.
  • Reviews synthesize findings into a to-do list sorted by severity (P1, P2, P3).

• Triage and Resolution:

  • Kieran uses an AI-powered triage command that walks him through findings and asks for human sign-off when ambiguity exists.

---

Key Features, Plugins, and Shortcuts

The Compound Engineering Plugin

• Open-source on GitHub: Includes commands for every phase—planning, working, reviewing, compounding, triage, and even video generation of new features.
  • Slash Commands: All flows are triggered via slash commands. The system can be used in full, or piecemeal (e.g., only the planning step).
    • “The beauty is you don't need to use this whole system. You can just say I use the plan phase and then I go manually code everything because I love to write code.” (Kieran, 39:29)

Permissions Workflow

• Dangerous Skip Permissions: Speeds experimentation by not requiring repetitive approval—just ensure sandboxing for safety.
  • “If you go in this mode, it will never ask you for anything. It will just keep going. That is good for certain flows...just make sure...your computer where you work is safe…” (Kieran, 42:12)

Parallelized Sub-Agents, Slash Commands, and Skills

• Slash Commands = business logic
  • “Slash commands are like, you trigger things… you want control over.” (Kieran, 47:02)
• Sub-agents = parallel or specialized tasks
  • “Sub agents are mostly, if you want to run something or do something specialized…if you want to do things in parallel, like, if you can do 10 things at the same time. Sub agents are the way to go.” (Kieran, 47:02)
• Skills = context-specific knowledge injection
  • “Suddenly Claude knows how to generate an image...just-in-time, like AI trick context.” (Kieran, 49:55)

---

Notable Quotes and Memorable Moments

• “AI can learn, which is really cool…So that's the seed for compound engineering.” (Kieran, 00:00)
• “It's like a QA team, basically. You don't even need to write a test. You just say, yo, just test it.” (Kieran, 00:18, and again at 33:10)
• “Compound Engineering is… best practices that I learned from using AI.” (Kieran, 01:54)
• “I haven't opened Cursor other than looking at text files in like the last three months.” (Kieran, 12:34)
• “I'm just thinking, what do I do always manually. And that's getting less and less and less because it's just taking over more.” (Kieran, 53:09)
• “It took me a year. So yeah, it takes a long time. But I do realize some people want their own… The beauty is you don't need to use this whole system.” (Kieran, 39:29)
• “You vibe with it?” (Interviewer, 18:14, tone: playful banter)
• “No one knows [about the ampersand trick to push to cloud], but it's pretty cool.” (Kieran, 46:21)

---

Timestamps for Key Segments

• 00:00-01:54 — Kieran on AI learning and the compound loop
• 03:33-07:34 — Live walkthrough: Planning with compound plugin
• 07:34-12:54 — Agents, skills, and best practice research
• 12:54-15:15 — Creating and maintaining "skills" for agents
• 20:00-22:22 — Compounding learnings across projects
• 29:01-29:52 — "Managing an AI team"—new engineering paradigm
• 33:10-34:05 — Playwright as AI QA tester and video artifact creator
• 42:12-43:41 — Skip-permission mode and safety
• 47:02-50:09 — Slash commands, sub-agents, and skills explained
• 53:09-53:42 — “Manual work declining,” big picture impact

---

Final Takeaways

• Compound Engineering is a practical, extensible development technique for AI-powered codebases.
• Feedback, QA, and documentation loops make Claude or similar AI learn and improve every iteration.
• Open-source tools, slash commands, skills, and Playwright-based validation make this approach accessible now.
• AI engineering is becoming more about orchestration and knowledge management than raw coding. Approach it like you’d onboard a new team member: systematize learnings and processes, and let the AI handle more each time.

---

Find Kieran on X (Twitter), and check out the open-source compound engineering plugin via the episode notes.

---

This summary captures the full flow and practical value of the episode for engineers, tech leads, and power users aiming to level up their AI code automation game.

Transcript

[Kieran]

AI can learn, which is really cool. So if you invest time to have the AI learn what you like and learn what it does wrong, it won't do it the next time. The beauty is that all these things together are synthesized into kind of a story to me, making sure those learnings are captured. And then the next time you create a plan, it's there, it learns. So this is the compound play, right? It's like a QA team, basically. You don't even need to write a test. You just say, yo, just test it. So if something breaks, it can fix it immediately and immediately validate whether it fixed it. The LFG command. So I have this command now. Everything we just did, testing and creating a video and creating a pull request, and it just runs for an hour and it does it.

[Interviewer]

Hey, everyone. I'm really excited to welcome back Kieran today. Kieran is a CTO for Quora at every and also my favorite cloud code power user. So Kieran is going to show us how to do compound engineering so that cloud code gets better each time you use it. And he'll also show us his exact cloud code setup to manage multiple agents and a lot more. I'm basically going to pick his brain a lot in this episode, so welcome, Kieran.

[Kieran]

Thank you so much. I know last time I really enjoyed talking to you, and I'm very excited to show and share with everyone what I learned because cloud code is picking up. Lots of people are using it now. Yeah.

[Interviewer]

It feels like half the conversation on social media is about cloud code these days. So.

[Kieran]

Yeah, yeah, we're like. We're in a bubble, but, like, I think the bubble is expanding a little bit, which I love because more people can create, which is amazing.

[Interviewer]

All right, so I'm going to share this slide. Okay, so I made this janky slide on compound engineering based on what you wrote. And do you want. Do you want to just cover this thing at the high level and then we can get into, like, the actual clock code?

[Kieran]

Yeah, yeah, absolutely. So compound engineering is. It's a philosophy, really, that I invented when I was building Quora. And it's just best practices that I just learned from using AI. And especially this started with closed code, when closed code launched a year ago, because there were things that worked and didn't work and they were frustrating. So I built a philosophy and what I really figured out very quickly was like, AI can learn, which is really cool. So if you invest time to have the AI learn what you like and learn what it does wrong, it won't do it the next time. So that's the seed for compound engineering. And there are four steps in the compound engineering philosophy, which is planning, first working, which is just doing the work from the plan. Then it's assessing and reviewing, making sure the work that's done is correct and then taking the learnings from that process and codify it. So this is the compound aspect. So the point is, for example, if you make a plan, do the work and then assess whether it's good, it's never completely exactly the right thing. There's always feedback or things that weren't exactly or you learned something. So making sure those learnings are captured. And then the next time you create a plan, it's there, it learns. So that's really the philosophy of the loop. And I have a plugin as well for that and we'll go into that. So it's a philosophy. It's also a plugin that I built that you can use. And yeah, that's the high level of everything.

[Interviewer]

Awesome.

[Kieran]

Let me show you what a flow like this looks like. So the four steps. So first, if you want to follow along, you can do that yourself as well. I have my terminal open here. It's warp. I've Claude code running in bypass permissions, so skip dangerously. That's how I like to go. We can go into when to use wad. That's how I run it. I'm just pushing things to go as fast as possible. If you want to follow along, this is the repo. So you run these commands, the compound engineering plugin, you need to add it and then install it. And then you have the exact same flow as I have. So you can just do this in your own project and follow along. So the first thing is, what are we building? And I am on this quest of making Quora Agent Native. And yeah, Quora is my product. It's an email assistant that screens your inbox and breathes twice a day. And there's an assistant as well inside the product. And the idea of Agent Native is that the assistant or the agent within the app can do exactly the same thing as the user can do. So, like if you can go to Settings, for example, in your app, then if you talk to the agent and say, can you change these settings? The agent should be able to do exactly the same. So I'm trying to get to parity there because it's a very important thing because it enables agents to come up with new ways of working. And it's really inspired by how Claude code works. Like Claude Code has access to your computer and can just do anything on your computer. And we figure out all these cool flows and things we can do suddenly with Claude and it's similar, you can bring that same spirit to your app. So what we're going to do is we're going to plan and it's called Workflows Plan since plan is now taken by the internal systems of Cloth code. So workflows plan and you give a description of what you want to do. And I will use Monologue, which is voice to text app. I don't like typing too much, so we'll do that and I'm going to explain what I want. I want to create feature parity with all of the things we can do in settings. So any settings the user can do in any of the views, I want to make sure that the Quora assistant can change the same things as the user. So make sure we look first for everything we can do as a user and then make sure to see how the assistant can do that. So through tools, through whatever we want, you can look at the agent native skill to learn how to best do this. So I give some direction here and it's going kick off here now and we can kind of see what it is going to do and why it's doing those things. So any questions so far or.

[Sponsor Voice]

This episode is brought to you by Granola. If you're in back to back meetings, you know how much work it is to take notes live and clean them up afterwards. That's why I love Granola, the best AI meeting notes app in the market. Here's how I use it. Granola automatically takes notes during a meeting and I can add my own notes too. After the meeting ends, I use a granola recipe to extract clear takeaways and next steps in the exact format that I want. Then I can just share notes directly in Slack with my colleagues or even get Granola to share their notes automatically. Honestly, of all the AI apps that I use, Granola is the one that saves me the most time. Try it now at Granola AI Peter and use the code Peter to sign up and get three months free. That's Granola AI. Now back to our episode.

[Interviewer]

I'm really curious what's doing behind the scenes. Like is it making a spec, looking through the code? Yeah.

[Kieran]

Yeah. So this is like you hear this in different places. Like you respect driven development, you have like Taskmaster, like all these things. You have planning modes and this is basically the planning mode from Claude, but it's a little bit Beefier, it's a little bit more. It will use more tokens, but also it will do better research. And really the point here is it looks at your current code, so it grounds itself in what you already did. So if there are patterns, it will pick up those patterns. It will look online, it will go search for articles that have been written about this and like, what are the best practices? So this is what others say is good, which is also very, very handy. And it goes look through frameworks you use. So if you use specific frameworks or libraries, it will go look up like, also it will check what version you use. So it's also important to use the correct versions because otherwise there might be a mismatch. So just making sure everything is correct. So those are the first three agents here. And these agents run as sub agents, which means the context will be separate from the main thread. And you can see it's already like 56,000 tokens, 77,000 tokens. 35. So it's like, it's. It's not cheap on the tokens, but that's not the point.

[Interviewer]

The point is to be on the max plan.

[Kieran]

Yeah, yeah, you have to be on the max plan too, because otherwise you run a few and you're out. But also the max plan is not very expensive. If this is your job, if you make money doing code, yeah, this is clearly value for the money. And also you, if you want to experience what the future is going to be and really push yourself, like, hey, how is it going to be? Yeah, you should just push yourself. Because our CEO, Dan, at every, he always pushes me a little bit because I'm like, yeah, but we need to look at the cost for this and it will cost us like hundreds of thousands of dollars if we just switch to the new model. And he says, yeah, but we should also know what we can do now. And if we don't know, we just get stuck in the past. So this is also for you as a developer, if you feel like I'm very scared, I want to see what's happening here. I want to feel what's going on. I want to see the code, let it go a little bit and just experiment with, like, how does it feel if you don't see what's happening here? Because it is a complete mind shift as well.

[Interviewer]

I mean, like, how much does the average developer cost per hour? Like, you know, the $200, $100 will pay for itself.

[Kieran]

It's nothing. It's nothing. Yes. Yeah, exactly. Yeah. So, like the goal. So the Goal of this, like, is to get a really good plan and then we as humans look at the plan. But obviously the goal long term is you just say one thing and it's done. So this is just getting towards a place where we know and trust certain steps and flows to get us to a goal. So, yeah, so at the end, I'll share one other command I have that just does everything in one go. So you don't need to even understand what all the steps are, because I think that's going to be interesting and very helpful soon as well. But if you are a developer, you want to know what's going on here because you want to tweak this, you want to make your own. You can use my plugin, obviously, but, like, even better is to use my plugin, see what works, what doesn't work, and make your own version of that or make your own flow so you really understand what's happening and once you do, you can just let it go.

[Interviewer]

Yeah, yeah. I love the best practices researcher and framework researcher because I think if you just use plan mode and cloud code, it's going to look at your code base, but it's probably not going to do this other stuff, right?

[Kieran]

Yeah, yeah, it's good for small things. I use plan Mode and Opus 4.5 is pretty good in doing things, but this is just. It's a little bit better. But I hope, like, at some point Boris will just copy paste this into Claude code and we'll have everything working well. So my goal is not to have a system. Like, ideally I delete this entire flow and everything works already.

[Interviewer]

But I mean, Boris is basically copying, man. He already copied your compound engineering.

[Kieran]

He's inspired. He's inspired, yes.

[Interviewer]

He's definitely paying attention. So.

[Kieran]

Yes, yeah, yeah, yeah, I know he's inspired, but also, like, I like, yeah, but, but he's do, like, he's letting people figure out what they should build and then they're like, building it and that's. It's really, really nice.

[Interviewer]

The funny thing about Boris is, like, he went on vacation for like, for like a week and then he shipped like 50 PRs or something. Right.

[Kieran]

Yeah. On Twitter.

[Interviewer]

So I'm just wondering if it's actually working. Like, how much does he show shipping? Like, how do you keep track of that?

[Kieran]

At least 100% is AI written by him now. So. And I agree, like, I think for me it's also 100% now. And yeah, I haven't opened cursor other than looking at text files in like, the Last three months, I think. Yeah.

[Interviewer]

Okay. And while we wait, like what terminal is. What terminal app is this?

[Kieran]

Yeah, I use Warp. I like Warp since, yeah, Warp. And it's AI based terminal as well, which is handy. If you like do things with Git and it doesn't work, you say, oh, just fix this. And then it will also fix it. So I like Warp also. I like that you can like split pains easily. Yeah, it's the one I like best. So, okay, so let's see. He did this. It's looking at the agent native architecture skill. So this is something I said to Luke at here. I said, hey, can you check the agent native skill? Because we have this like what we try to do, if there are specific information that's important, we try to distill it in skills and that means you can put a lot of information in one place. So for example, this one here, let's open it here. Agent native architecture. So this is a very extensive long document about how to build apps like this. And there are lots of references here as well. And if you load all of this in context, you would just kill your context. But it's too much. It's too much. But it's also very good to have access to this. So a skill is this way, like it's kind of just in time context. So, so whenever you need it, it will like think like, oh, do I need it now? It will pull in that skill file and then if it needs even more, it can look at the resources inside there or you can run scripts. So this way to put things like around a specific subject or a tool or a skill that it can use then. So I love that. And you can like create your own skills that you reference. And this is a way to make the compound engineering plugin yours where you have your skills. For example, if you do iOS development or you have like a, like a go CLI thing going on, like I don't have any of that in my plugin, but you could have your skills. And the compound engineering plugin will read your skills as well and will also apply these. So this is a way to make it your own. And yeah, I can advise that for sure.

[Interviewer]

And you're basically, you're obviously not handwriting the skills, right? Like you're basically getting.

[Kieran]

No, no, no, no, no, no. So there is a skill create agent skill in the combat engineering plugin as well. I think there are others, but that's the one I have. I think there are some from Anthropics themselves as well. So yeah, don't write handwriting skills. No. But make sure to read them and review them and see if it makes sense and if it's good. Okay. So it did that. It's now doing the spec flow analyzer. So I introduced this as I noticed that sometimes it zooms in on things a lot and it. Sure, yeah, it like figures out I need this plugin and this page. And it's so zoomed in that it forgets that it's part of a bigger picture. And sometimes it just forgets a complete page or thing or it's not hooked up to a flow or something like that. So the SpecFlow Analyzer is like. Imagine you're a user with like specific Personas and go through. Do you miss anything? Did we miss anything in the planning? And that's very good to have like this. So that's the last step and then it writes the plan and then you can do other things. So let's see what it does here, what the plan is. Okay. So it is done with the writing of the plan, which is great. And it will ask me what to do next. So there are a few things we can do here. Can open the plan in editor, which means let's look at it. I like to use an editor or like a viewer because I like to feel really good about the design of whatever I'm reading. So we're going to do that. But there's another option, Deepen plan, which is like, it just goes ham. It loads everything it can load and reviews the plan does add like any skill you have. It just goes wild. And this is just like, if you vite code, this is great. You can also trigger this, like, automatically from the start, but it just goes ham on tokens and does everything it wants. And it's cool when you vibe code because, like, there's nothing to lose really. And you have tokens left. So. Yeah, why not?

[Interviewer]

Yeah, why not? Yeah.

[Kieran]

So the next one is the plan review. If you want to review the plan, not manually, but you want like an agent to look at it, this is handy. So if you don't want to read it or you can say, yolo, start work. Let's. Normally I open plans and this is also good. You can share it with your team, with other people. You can ask for feedback like rfc, however you want. I use an app to read my markdowns and I like it like this because it looks pretty.

[Interviewer]

Yeah.

[Kieran]

Instead of the terminal, it's just more pleasant to look at. Very boring plans and specs and things. If it looks nicer I'm just more like. It's just nicer. So I have this app and I.

[Interviewer]

You vibe with it?

[Kieran]

No, this is a typo aura. But I already have people reach out that said they vive coded a free version. This is 10 bucks or so.

[Interviewer]

So it's not a lot.

[Kieran]

The theme is yd, so if people want to witty or something. So assistant feature parity. Enable core assist to modify all settings. So analysis it says hey, okay, so general. So add a user doesn't exist. Categories, reordering doesn't exist, but most of it resettings is there, subscriptions is not there and tokens also. So actually we're pretty good. We just need the general. The user edit we need. Okay, so blah, blah, blah, blah, security. So these come from different places. There are different angles to a plan always. So Google Briefs is one. I like to have an example piece of code like pseudo codes because I can already feel or see if this is completely wrong if I see any red flags or not. But it looks pretty good. So time zone. Okay, so it has different, different tools. So my question is now, so I'm an engineer. So if you're not an engineer, you could say, yeah, I have no idea what this is and just do it. Which is perfectly fine. I think this is a good thing to do. But if you are an engineer and have opinions, this is a point where you can compound or iterate. So let's try that. So because like I, yeah, I see all these tools, but I also think these are a lot of tools. Can we not somehow consolidate this? So let's see. Okay, I see you create and add a lot of individual tools. Is there a way where we can create one tool that can do multiple settings so it's less heavy? What about that? What do you think about that? Yeah, so let's see what it does. So like, and it's important to do this here because if you already started implementing this and you're like an hour further or half an hour further or more tokens further, it's harder to take a step back and say no or rewrite or you have all these things. So if you do it, if you spend time, it's better here. So benefits. Yeah, sure. We can do update settings tool. And what I want to do is I want to compound this knowledge because I think this is like, this is better. So I want to say compound boom. So I'm going to run the compound flow and it will understand from the context here what it is about and it will start to create some documentation about things like this. So next time when it starts writing a plan, it will pull in that information and ideally never make this mistake anymore.

[Interviewer]

Like where is it going to write the instructions though? Like just the default.

[Kieran]

Yeah, so there's a docs directory and it will organize learnings inside the docs directory and Claude in planning will then look for things that things might be relevant. So there's some front matter in the top, so you can search on keywords as well. But it also has the option to update your ClothMD file. Like a very easy way of to do compound engineering is just saying, can you update my clothmd file? So if you don't have the plugin and you want to compound, it's just like, hey, don't make this mistake again. Add this to ClaudMD. This is like the easiest way to do it. But

[Interviewer]

that's basically the prompt, right? You just update because that thing gets inserted into the prompt each time.

[Kieran]

Yeah, exactly. So anything that is in your clothmd file will always be inside the prompt. So it will follow pretty directly. So if you want to start with a very light version of this, if you see it make a mistake, just say, hey, add this to ClothMD. And I do this all the time actually as well because sometimes it is something like a general knowledge, not very specific. It's like, hey, how do you start the server for example? Or like it tries to do something in a weird way. I'm like, it should just never do it. And then I'll say just store it to ClaudMD. I don't use the compound flow. So yeah, it's not one or the other. You can use everything together. It's Claude code and it all works together. So yeah, you can see here it's storing it in architecture decisions in solutions and docs, which is available then as well. And it loops through other things I already have. So if it's related, it will append it there and it will consolidate it. So and the beauty is this is just files in your repo and Claude reads files in your repo and it's really good at that.

[Interviewer]

So yeah, I interviewed someone else who, yeah, she has like extensive documentation for Claude and she doesn't sometimes doesn't even read whatever cloud updates. She just trusts Claude to update the docs for her.

[Kieran]

Yeah, I do the same. Yeah, I like, I, yeah, I don't, I don't. Yeah, so this is like this old versus new paradigm of engineering. Like yes, you have old school engineers that don't use AI, but let's talk about the engineers that use AI to write code in cursor or something like that. But they all want to see the code. Like, if anything changes, they're like, I better see the changes and approve every single change. And there's this new wave where, like, I'm at least at, like, lots of others too. But, like, it's a little bit more of like, I trust you. I don't need to look at all the codes. I don't need to read all the codes, but I have systems and ways I work with AI that I trust, and through that I can let AI do things. And I think with documentation, like that is the same.

[Interviewer]

Yeah, documentation doesn't affect the product. So it's just docs.

[Kieran]

Yeah, yeah, it's docs. But I want to say I do the same for, like, even for product. Like, I do look at all the code that I do for Quora, for example, because thousands of people use it. But if I vibe code something myself or something experimental or maybe a part in Quora, that is just for me to experiment for now, I don't look at all the code all the time, because that's not the point.

[Interviewer]

That ruins the vibes, man. If you keep looking at all the

[Kieran]

code, I know it ruins the vibes. And also, that's the whole point of compound engineering, is to make sure that if you look at the code and you find something, that you make sure that you teach it so that next time you don't have to look at the code. So it's capturing however you work, really, and to make sure that that is always working. Okay, so now we compounded here, and yeah, we can do work, so we'll do that. So it compounded that. Now the next step is to do the work, which is just letting it rip. And obviously it changed the plan. Now with the single tool call. So update settings is now you can do as many iterations here as you want, obviously, But I feel confident now that this is the way I want to go. So if you're very lazy like me, you don't even compact or create a new session, but probably that's better. So let's just do the better way. So let's do new here. So we clear our session. We have a clear context. Clear context because it's all captured in the plan, really. So we go workflows work, and then we paste in the plan and I use markdown. But you don't need to use markdown. Yeah, you can use GitHub or linear or whatever you want. And if you have a GitHub CLI installed, it will pull from GitHub if you have the linear integration somehow like it will pull from there so you can find a place wherever you want to live. So if you're more. If you're a GitHub focused shop or engineer or whatever, then just do it there.

[Interviewer]

So what's the difference between this work step versus just using let it rip or go build it? Yeah. Ask you a few questions.

[Kieran]

Yeah. So yeah, clearly you can say just do it or something like that. But there's one thing in the beginning here, especially since you have a new fresh context here, it will like figure out if anything is missing because sometimes things are missing. So now it says I have a few questions. So the plan shows updating user and account in a transaction. If only name or time change should still wrap a transaction. Or is it also changed? I mean that's a good question that we didn't really answer it in the research. Yeah, sometimes there are good questions where it's not super well defined. You miss something or it removes something. But generally, yeah, it just goes. But it does make a plan now how to tackle this. So it is a little bit more than just do it. It does build a plan how to do this. Let's go. I'll just say let's go. You figure it out. Just do the best. Yeah, and that is fine sometimes. And just having these questions here is good for context because it will start thinking about these things and why it is best. So that's why like this is kind of like thinking mode basically. But it's like us pushing it to think or like what could go wrong and then it will think, oh, that could go wrong. And then it starts thinking about how it could go.

[Interviewer]

Right.

[Kieran]

So it's like traditional prompt engineering here that just works for you if you

[Interviewer]

have these tokens, dude, it really feels like. Yeah, it really feels like you're like a tech lead or like an em managing like this engineer and you're just having like meetings with it.

[Kieran]

Right?

[Interviewer]

You're just like reviewing plans.

[Kieran]

Yeah, absolutely. Directions. Yeah, yeah, yeah. I think last time we talked about it as well. But like skills you need are like tech lead skills and like management skills because you're managing these agents. And this actually feels like, feels very hands on still. We have to still do all of these things. I think the future we're very near is where you just do one thing at the start and you get the end result and it's pretty good. And obviously you need to do the Compound loop for a little bit. So you need to train it. But it's similar to onboarding a person on your team. You need to get them on board, get them used to your code. But once that is done, you can let them go and really just run with it and do more end to end.

[Interviewer]

Okay. So it looks like it's almost done. It's running tests already.

[Kieran]

Yeah, like, this is it. It did the feature and it's writing the test. So that's really cool. And after that. One of the coolest Things of Opus 4.5 is the testing because is really good at using playwrights and really good at understanding flows. So this I love. Like, before, I still had to go in and manually test things like clicking on things like obviously writing test it was good at. But now we can have Playwright work like it never worked really well. But with Opus 4.5 is the first model where I think Playwright really works. It's not super fast, but it works well.

[Interviewer]

And Playwright just for audience is like. Basically like an MCP to have Claude see the browser, right? See the browser.

[Kieran]

Yes. Yeah, it's just a Chrome. Like, you link Chrome to Claude code and like, it can control your Chrome window. There is a Chrome plugin for Claude code as well, which you can use too. And that's pretty good. But for me, I like Playwright a little bit more since. Yeah, you can record the screen, you can take screenshots, you can like change the size of the screen. I do things like that where I record the whole video of the whole flow and put it to the pull request automatically as well. So I just like Playwright a little bit more. But whatever works for you if you like to use something else.

[Interviewer]

So basically to use playwright, you just type one line to install it. Right. And then you just do playwright test. And what it's doing right now is loading a browser behind the scenes and playing with the product.

[Kieran]

Yeah. So it's. Now it's still. Actually it's fixing the test still. But after we can just. Yeah, okay. Let's say the feature is done. These. I think it will work because these are just tests. It Writing for specifics.

[Interviewer]

Yeah, we don't.

[Kieran]

Who needs it? I need tests. But just for like, us. We're very. We want to see it. We're too excited. So you run playwright test and what this command will do. This is also part of the compact engineering plugin. It will write a plan of like, what are the features introduced in here? Just keeps going. Okay, well, that's good. Yeah, Write a plan. Like what to test, what is new, what is introduced. And then let's just say for now, skip the test and go test in Playwright. We'll get back to that after. So you can see how good Opus is with following directions. Like, we have the Rolf Wiggum loop thingy go viral, but I haven't seen it to be very, very needed because it's pretty good at following directions. Okay, so here we go. It's funny because it's now on dev, please. Okay, so, yeah, so we're here. And now it's going to control the screen. So I will just move this a little bit. Yeah, let's go. So it's controlling it, taking screenshots, and it can do all of this. No hands here. Look, it's not me. And it's just testing the feature.

[Interviewer]

Okay, so it's kind of like a browser use thing, right?

[Kieran]

It's a browser use thing. But the beauty is that this was kind of a missing piece. Like, you have system or integration tests, obviously, but this is like the ultimate test, whether something works, which is like, does it work? And it's very easy. You don't even need to write a test. And it's not no overhead in, like your CI or anything. You just say, yo, just test it. It's like a QA team, basically. And it's very nice. And you can say, just do this for an hour, think of everything that can go wrong and really kick the tires and, like, try to break it. And it will try to do it. And the beauty is it is in close code, so if something breaks, it can fix it immediately and immediately validate whether it fixed it. So it's like this iteration loop. Using this is very, very cool and very, very powerful.

[Interviewer]

And if something like breaks, can also inspect and see all the console errors and stuff. Yes.

[Kieran]

Yeah. It can control the entire browser. So it can click on elements, it can run JavaScript, it can read the console log. So basically, you, as an engineer in Chrome, it can do everything. So it's really cool. And also, one added thing is like, Quora connects to Gmail. I was doing a feature where I just launched it, where we do email signatures and drafts, and to see if that works, you need to go to Gmail. And how do you write a system integration test to go to Gmail? You're not doing that. But with Playwright, I could just log in with my Gmail account and say, hey, I'm logged in with my Gmail account. Just see if it works. And it went to Gmail. It's just A browser. So it's magical to see work. Well, it works. Our feature works. Yeah. Which is cool. So this is a good state. But what I always do after that is making sure there are no security risks or if there's no slop or if it can be done more simple. Like there are all these things that can always be better. The review commands, which is the last command. Or is the. It's the command we didn't use yet. We used the compound already.

[Interviewer]

This is the assess stage, right?

[Kieran]

Yeah, it's the assess state. Yeah. It's running reviews from certain perspectives and it's my perspective. So I have an agent that has my way of working. I added a security person, architecture code, simplicity reviewer, which is also a very good one. Which, like. Yeah, Boris has the. Has one too. And he shared it, I think this morning on X. So anthropic does it too. Like, there's also one that reviews whether this is agent native enough. DHH is the creator of Rylls and he was just like. He has a very opinionated view on things, which is hilarious always. And the beauty is that all these things together are synthesized into like kind of a story to me. They're like priority things that come out of this and they're not being fixed immediately. But I'm asked to say what I want and say, yeah, this sounds good, this sounds good, this doesn't sound good. So let's finish these.

[Interviewer]

Yeah. Because otherwise if you just say like, just like, you know, clean up the AI slop code, it's going to do. It's going to start just like changing the code, right?

[Kieran]

Yeah, exactly. Yeah. Because we like the point of like we are at a stage where we tested everything, we reviewed the plan and it's too easy to now go into a direction where it increases scope or delete stuff. And like, you need to be careful and you're not going to change too much now. But you want like very knowledgeable people or agents or things to look at it from a certain perspective.

[Interviewer]

Amazing.

[Kieran]

Yeah. Which is like, this is the point where like before we. We had like very wide, brought it back to a plan, narrow plan that's very focused and we had that focus plan being worked on and since it was focused, it kept to that plan. But now we need to make sure that we didn't miss anything. So we're wide again. So there's like going in and out from. From looking different perspectives, which works.

[Interviewer]

Yeah.

[Kieran]

So it compiled everything into like, it has things. What it's doing now is creating a todo directory. So great. We don't have any P1s, which is great. P1s are like, you should never, never merge this because you got security flaws. We have P2 which sometimes are important and P3 is like you kind of ignore. But yeah, nice to have. And what it's doing is writing it to my to do. I have a folder todos and it's writing them there. And you can see also I have this status line here where I can see how many to DOS are pending. But what I like to do, I don't like to read a lot of stuff. I want to like kind of the AI to walk me through what to do or like how to go. Think about it. So I have a command called triage. And triage will just in a sort of conversational way walk me through all the, all the findings and then ask me what do I want to do. And then it makes the decision. And then yeah, after that I just run one command to resolve everything and a PR is created. So yeah, so for example, this is name length validation. I mean, okay, sure, let's do it. It's like small things, but that is fine. So it will crash because it's database backed. But this is good. Okay, so we do that.

[Interviewer]

So I say just real quick for me to build all these sub agents that you have for each step of this comp engineering will take forever, man. So the fact that you're making this available on GitHub for free is great. I basically take Kieran's stuff and build my own projects.

[Kieran]

It took me a year. So yeah, it takes a long time. But I do realize some people want their own and they are more inspired and you can pick one of these. But the beauty is you don't need to use this whole system. You can just say I use the plan phase and then I go manually code everything because I love to write code. Sure.

[Interviewer]

Or it's all triggered by slash commands, right? Like all.

[Kieran]

It's all slash commands. So you don't need to use all of this. So yeah, so it's marking these as ready and then now I'm happy. For example. And then say resolve todo parallel and that's it. It's going to pick up all these things. It creates like a dependency graph and how it thinks it can resolve it. And then sub agents will pick up all the to DOS and push everything. And yeah, then we have PR and then we're done. And this whole flow, like how long did it take? It's very quick and very cool. So One thing I want to show. What if all of this was just one command? So I have this command now that I tried out yesterday. It's the LFG command. And basically everything we just did, I just say in a command, just do all of this. And I have a Ralph Wiggum loop in the start and basically it just does everything we did, plus a little bit more and testing and creating a video and creating a pull request and it just runs for an hour and it does it. So you can.

[Interviewer]

What do you mean? Create some marketing video or something?

[Kieran]

Yeah, yeah. Marketing video, product marketing details, change log, everything. So it's just like this LFG ad reeves to clique or whatever you want and then it goes so. And I think we're very close to that. You see a lot of people with like agent orchestration, stuff like that. And I think to get agent orchestration, very. Yeah, to get it right you need a system like a compound engineering or whatever you have. Because you need to make sure. Yeah, it's. It's like the harness plus your own harness. Like.

[Interviewer]

Yeah. Because you said you set up all this shit over a year, so now it's making your life a lot easier. Basically.

[Kieran]

That's what it is. Yeah.

[Interviewer]

All right, dude, let me ask you some rapid fire questions. Let's start with the permission thing. So like one of my pet peeves is just like super annoying. It keeps asking me for approval for permissions. So.

[Kieran]

Yes.

[Interviewer]

So basically. So maybe you can exit clock code and like show us like. So you just type a CC and then dangerous skip permissions. Is that.

[Kieran]

Yeah, So I have an alias for. So I. What I do is I do cc, but what that means is just an alias for

[Interviewer]

the full thing. Got it?

[Kieran]

Yeah. So it's just called dangerously skip permission. So if you go in this mode, it will never ask you for anything. It will just keep going. That is good for certain flows. If you are a system like this works better if it just goes because the checks are not in between. The checks are when you do a pull request or when you merge code. So just make sure that if you do this, don't share your SSH secrets with it. That can delete your production data. Just make sure the sandbox or your computer where you work is safe because it could do anything you can do, but it won't do it. Technically it can, but it doesn't really do it. But also you can start approving things. So if you don't want to do that, you just use Claude and you say add this to permissions and it will remember it for next time. And that's also perfectly fine. It will just be painful in the first week, but after that it will not be.

[Interviewer]

Yeah, there's like a settings file or something, right? Where you can add a bunch of permissions.

[Kieran]

Yeah, yeah, it will add it to your repo or however you set it up. There's lots of flexibility there.

[Interviewer]

Yeah, but I think in practice, like, I think Opus is smart enough to not just like randomly delete folders. So like.

[Kieran]

Oh yeah, like, Opus will not do stupid stuff. No, it will. It will do smart stuff. It's not doing anything it shouldn't do. Like, like, oh, it deleted my database stories. Like it happens. But I don't think it's Opus 4.5.

[Interviewer]

Okay, so let me ask you another question. So you just show the way to like LFG and like, you know, just have it work for an hour. Right. So what, what's your preferred flow to like, do you giving instructions over the phone too? And like, do you use the cloud code app or. Which prefer.

[Kieran]

Yeah, so I. So one really cool thing, like not a lot of people know about it actually, is if you're in cloud code, you can do the ampersand sign. And what that will do is it will do whatever you do here. So you can, you can say workflows plan,

[Interviewer]

it pushes to background.

[Kieran]

Yeah. Okay, so if you, if you install the cloud for some reason I haven't installed it now, but it will push it to the background and it will push it to Claude code on the web so you can continue conversations on your phone. So here, here you can see I have Claude, the cloth app and you can see the repos here. And I can even work on local here, which is also cool. But I use it in the terminal. But what it does, it pushes from the terminal and you can pick it up here. So it will push the session, whatever you had up to the cloud, which is really cool. And also you could continue. So for example, we're here and here you can see the pull request to be is going created. So we're successful here. Like this is the feature and it looks great. Yeah, so that's a feature. But if you, if you're like, oh, and hurry, continue the test here because we didn't finish the test and it will. Because this.

[Interviewer]

So it should go to the cloud app.

[Kieran]

Yeah, yeah. So, so now, yeah, so now it should start here. Yeah, so here. There we go. So it can use here in the app and you can do that on your Phone too. I have to say, the Cloth phone app is not the best and there are bugs here and there, but this is really cool. And you can do it the other way around where if you are here, you can say open and cli here, and you can continue a conversation from the web and keep going.

[Interviewer]

Also, you just have to type ampersand. I had no idea, dude.

[Kieran]

Yeah, no one has that. Yeah, no one knows, but it's pretty cool.

[Interviewer]

You can do localhost changes too, from this.

[Kieran]

It will create an entire new environment in the cloud, but it will work like, it will have all the notes and the things. So, yeah, it will work fine. Yeah.

[Interviewer]

Okay, so let me ask you another question. So I think you showed us a little bit, dude, I think all this shit about slash commands, sub agents, hooks, skills, it's, like, overwhelming, man. It's overwhelming for someone who's trying to learn this stuff. So. Yeah, but I think your workflow is use slash commands to trigger these workflows that then call the sub agents. Right? And then maybe those sub agents can call the skills. Is that kind of how it works?

[Kieran]

Yeah, because the confusing part, they're all the same, but slightly different. And it's like. Like when to use what. So I'm triggering now to create a video to show how well this works and add that to the pull request as well. So if anyone uses that. So we'll just leave that running. So how I think about this, slash commands are like, you trigger things like do this or do that, or it's like, commit this, create a pull request, or like, whatever you do. Like, it's something you want control over. Like, it's you saying, do something. And the beauty is it could also be the agent, because my LFG is like a list of other slash commands. So it could be you instructing the agent to call commands as well, which is also good. That is that. And it works really well. Sub agents are mostly, if you want to run something or do something specialized where, like, you don't need the whole context, but you want, like, a result. Like, like, I just want someone to tell me or something to tell me what the answer is, or, like, how good it is or what's wrong, where you don't really care about the full thing, which is like, review agents are great or like research agents, because you don't care about the 30 books it reads. You just care about what the answer is. So that's when I would go for agents. Also, if you want to do things in parallel, like, if you can do 10 things at the same time. Sub agents are the way to go because that's how it works. Even though you can do tasks, you can trigger. And the confusing part is you can trigger sub agents as well manually, and you can all do these things, but that's not how they're made.

[Interviewer]

So basically, you don't really trigger sub agents manually. Right. You trigger through some slash command.

[Kieran]

Yeah, I never add a sub agent. I never do that. No.

[Interviewer]

Okay, makes sense.

[Kieran]

No, because I like to, like, the slash commands are kind of the business logic or something. Like, this is how the agents should work together. And I say, now do this specific thing and then it will do the thing and then your skills. And we touched on it already. Skills is just like, if there is like something. For example, generating images on Nano Banana using the Gemini API, like, there's no image generation in Claude or Claude code, but it will be cool. Why not? So that's a perfect way to create a skill where you just have a skill that says, hey, if you want to generate an image, I'm here, load me, and I have some scripts and it works great. So then you can say, I want to generate an image. And then Claude thinks, oh, I have a skill that knows how to generate image. Let me put that stuff in.

[Interviewer]

Yeah.

[Kieran]

And suddenly Claude knows how to generate an image. And that's like, just in time. It's like AI trick context. Yeah. It's like injecting knowledge at that point. So, yeah, that's when I use a skill. Yeah.

[Interviewer]

You know, honestly, like, the skills don't get triggered that well. Like when I use the Claude app, it doesn't get triggered that well, but maybe in cloud code it gets triggered better.

[Kieran]

You just need to be very explicit. Like, I literally say, like, use this skill for. And then it does. Okay. Yeah. If you're very specific. And also make sure that you follow the best practices, writing the skills. There are some, like, description, what the description should be, because there are some nuances in, like, you should say, not like, when to call it, but like, I can do this and this and this or something like that. So it aligns better. Yeah.

[Interviewer]

Okay, well, let's close this video that you're generating. So how are you going to generate this video marketing video? You're using Playwright or.

[Kieran]

Yeah, so it's. Yeah, it's. It's now using playwright and it's doing stuff.

[Interviewer]

So it's like screen recording. Is that what.

[Kieran]

Yeah, it's screen recording and then converting it to like a smaller size and it's uploading it. It's recorded and normally it uploads it. Open the video and then we'll assign it to the pull request. So I'll just show it here. But it made a video automatically showing the flow.

[Interviewer]

That's great.

[Kieran]

Which is really handy. Like if you review code of someone else and you open a pull request with screenshots of the changes, sometimes before, after, and a video of the full flow. That is great. So let's go. So this is it, the video.

[Interviewer]

Oh, that's awesome. They can share in Slack or like when you're.

[Kieran]

Yes, exactly. And it's uploaded. There's a. Yeah, so interesting.

[Interviewer]

It's.

[Kieran]

So it's not always. See it started here, but you gotta review it.

[Interviewer]

Yeah, you gotta review it.

[Kieran]

Okay, so it is. Yeah, so it is doing well. Gotta review it. But it's recording a video and like 9 out of 10 times this works great. And also this feature normally would have had the review already and like some testing before. So it's like. It's more smooth. But it's really cool that this is like an artifact you can create and you can do it however you want. You can use it however you want.

[Interviewer]

Just imagine this is part of your compound engineering GitHub.

[Kieran]

Yes. It's all in the compound engineering plugin. You get access to all of it.

[Interviewer]

That's great, dude.

[Kieran]

Yeah, yeah. So it's all here. And if you want to only use a command, you just go into commands

[Interviewer]

and you can see.

[Kieran]

Yeah, you can see all the commands here. You can say, hey, the feature video is an interesting one. Just copy this to your local directory. That works as well. You can read everything here.

[Interviewer]

Okay.

[Kieran]

So. Yeah, that's about it.

[Interviewer]

Yeah. This is amazing. I think the thing I'm most blown away by is actually the playwright stuff like the fact that I can just start testing and make a video. That's pretty amazing.

[Kieran]

Yeah, it's really cool because it's really like I'm just thinking, what do I do? Always manually. And that's getting less and less and less because it's just taking over more. Which is great in my view at least. Yeah.

[Interviewer]

Awesome. So we'll put a link to the compound engineering plugin in the description. And Kieran, if you want to find, you just search on X. Yeah, find me on X.

[Kieran]

And also I write about all this stuff at every point. Also recommend checking that out, but. Yeah, pleasure.

[Interviewer]

Yeah. This is so much more fun than, you know, doing all the madmanual stuff. So thanks. So thanks.

[Kieran]

I know, I know. Yeah. Cheers.

[Interviewer]

Cool. All right. Thanks, Karen. See you.