The argument in one line.
Stop copying skill libraries from GitHub and build your own lightweight five-step loop—Research, Prototype, Plan, Build, Test—that compounds over time and actually fits your codebase.
Read if. Skip if.
READ IF YOU ARE…
- You're building with Claude/agentic systems and currently clone skill repos wholesale, wanting to compress multiple libraries into one portable mental model.
- A developer 6-18 months into agent-driven workflows who's hit friction scaling custom skill systems and needs a systematic collapse of common patterns.
- You ship incrementally in sprints and need a five-step loop you can hold in working memory without re-reading documentation between projects.
SKIP IF…
- You're still in your first 2-3 weeks with Claude and haven't yet built a custom skill yet — this assumes you know what a skill.md file is and why you'd want one.
- You work primarily in non-agentic workflows or use Claude only for one-off tasks, not repeated project harnesses.
The full version, fast.
Stop cloning every viral skill repo and build your own lightweight harness instead, because the best agentic system is the one you accumulate from your own code base over time. Across Gary Tan, Matt Pocock, Adi Asmani, BMAD, superpowers, and Everything Claude Code, the same five-step loop keeps surfacing: research the idea in ask mode, prototype a front-end-only wireframe with dummy data, plan in vertical slices using the agent's native plan mode, build incrementally, then test with a mix of automated checks and human smoke testing. Write skills only when the agent repeatedly fails, keep them to a few paragraphs, treat them as living documentation, and add a polish pass with a second model when stakes are high.
Members feature
Chat with this breakdown.
Modern Creator members can chat with any breakdown — ask for the hook, quote a framework, find the exact transcript moment. Unlocks at T2: refer 3 friends + add your own API key.
Create a free account →Where the time goes.
00:00 – 01:04
01 · Cold open + promise
Surveyed all major skill libraries. Promise: distill to reusable patterns. Sponsor mention (CodeRabbit).
01:04 – 01:45
02 · What are skills again
Skills = SKILL.md files with front matter, always loaded into model context. Agent Harness diagram: Planning, State Mgmt, Memory, Tool Runtime, Skills, Evaluators, Reasoning Engine.
01:45 – 03:15
03 · Skill libraries are trending
Explosion of community skill repos. Everything Claude Code at 183K stars. Common denominators across all of them.
03:15 – 06:08
04 · Library 1 + 2: Addy Osmani + Matt Pocock
Osmani: spec to plan to build to test to review loop. Pocock: diagnose, grill-with-docs, TDD, prototype step.
06:08 – 06:30
05 · Test-Driven Development
All frameworks advocate some TDD. Caveat: agents can cheat their way through tests. Still worth it to prevent regressions.
06:30 – 08:17
06 · Library 3: Gary Tan (gstack)
YC CEO. Opinionated, Rob calls it overengineered. Standout: office-hours skill, 6 forcing questions about your startup idea.
08:17 – 10:00
07 · Library 4: Everything Claude Code
183K stars, 170 contributors. Memory, continuous learning, verification loops, sub-agent orchestration, heavy security focus.
10:00 – 12:40
08 · Spec-based libraries
BMAD: enterprise BA to PM to architect pipeline. SuperPowers: lightweight, Rob's favorite. OpenSpec, GSD, Speck Kit also covered.
06:42 – 08:51
09 · Sponsor: CodeRabbit Atlas
Atlas: layered PR diff view. Breaks code into data shape, business logic, testing layers with AI summaries that update as you scroll. Free for limited time.
09:11 – 12:32
10 · The Simple Skill Stack
The portable 5-step loop: Research (ask mode), Prototype (design mode, frontend only, dummy JSON), Plan (native plan mode), Build (vertical slices), Test (automated + human smoke test).
12:32 – 23:40
11 · Build your own system
Start with natural language prompting. Only create a skill when the agent makes a repeatable mistake. Keep skills to a few short paragraphs. Skills.sh for team sharing.
23:40 – 25:32
12 · How you win as a builder
Your bespoke harness built over time on your specific codebase is the moat. Skills are documentation and go stale, so be selective.
Lines worth screenshotting.
- Every major skill library — Gary Tan, Matt Pocock, Adi Asmani, Everything Claude Code — converges on the same five-phase loop: Research, Prototype, Plan, Build, Test.
- A skill is not just a prompt in a folder; it also contains a description the model checks every invocation, step-by-step instructions, and tools like scripts and API calls.
- Prototyping the frontend before the backend dramatically speeds the build phase because the agent has a concrete visual target and doesn't slow down on database decisions.
- Every framework advocates for test-driven development so that new AI-generated code can't silently break what was previously working.
- The most powerful skill system is bespoke — built incrementally for your own workflows — not a cloned repo from someone else's GitHub.
- Gary Tan's YC-CEO office-hours skill forces six founding questions before any build starts, which differentiates builders who know what to build from those who are just fast.
- Adi Asmani's approach breaks every build into vertical slices the agent can handle and verify one at a time rather than taking on the whole system at once.
- The bMAD framework is enterprise-grade, modeling a business analyst, product manager, and senior architect working together — too heavy for solo builders, useful for teams.
- Everything Claude Code hit 182,000 GitHub stars, making it one of the fastest-growing open-source projects ever — demonstrating the market demand for shareable skill libraries.
- Spec-based systems and skill-based systems overlap heavily; the real differentiator is whether you understand what's inside each skill well enough to debug when it fails.
- Breaking a massive monolithic skill into smaller composable ones makes failures easy to locate and improvements compound across everything that uses the shared pieces.
- The hybrid approach — taking principles from multiple libraries and building your own lightweight harness — outperforms any single off-the-shelf skill system for your specific context.
Stop cloning repos. Build the loop.
Rob Shocks playbook
The 5-step loop is all you need from any skill library, and you don't have to install anything.
- Run Research as an ask-mode interview session before every build.
- Add a Prototype session type in JoeFlow that enforces frontend-only, dummy-JSON constraints.
- Lean on native plan mode in Claude Code — it already creates phase-based markdown plans without a skill.
- Only write a new SKILL.md when the agent makes the same mistake twice — not preemptively.
- Keep every skill to a few short paragraphs. Bloated skills eat context and confuse the model.
- Steal Gary Tan's office-hours pattern: 6 forcing questions before any build session begins.
- Your harness is your moat — the longer you build on one codebase, the more unreplicable it becomes.
Terms worth knowing.
- Skill
- A reusable natural-language prompt stored in a special SKILL.md file with front matter (name, description) that an AI coding agent loads automatically so it knows when and how to apply that capability.
- Front matter
- A small block of metadata at the top of a markdown file — typically name and description — that tools read to index or activate the file without parsing the whole body.
- Skill library
- A shared collection of prebuilt skills, usually hosted on GitHub, that developers install into their AI coding agent to standardize how it researches, plans, builds, and tests code.
- Agent harness
- The surrounding scaffolding — prompts, skills, modes, memory, and verification loops — that shapes how an AI coding agent behaves on a project, as opposed to the raw model itself.
- Spec-based development
- A workflow where you first write a detailed specification of what should be built, then have the agent produce a plan and code strictly against that spec rather than improvising from a one-line request.
- Vertical slice
- A small end-to-end piece of a project that touches every layer (UI, logic, data) so it can be built and verified on its own before moving to the next slice.
- Test-driven development
- A practice where you write automated tests describing the expected behavior before writing the implementation, then make code changes until those tests pass.
- Context window
- The maximum amount of text — instructions, files, conversation — a language model can consider at one time. Loading too much irrelevant material crowds it out and degrades the model's responses.
- Sub-agent orchestration
- A pattern where a primary agent delegates subtasks to specialized secondary agents (planner, coder, reviewer, etc.) and coordinates their outputs into one workflow.
- BMAD
- An enterprise-oriented agent framework that simulates a full software team — business analyst, product manager, architect — collaborating in sequence to enforce a formal software development life cycle.
- Superpowers
- A lightweight community skill library for AI coding agents focused on a small, opinionated set of prompts for planning, building, and reviewing code.
- Pull request
- A proposal on a code-hosting platform like GitHub to merge a branch of changes into the main codebase, giving teammates a place to review the diff and discuss before it lands.
- Diff
- A side-by-side or inline view of what changed between two versions of a file, with removed lines and added lines highlighted so reviewers can see exactly what a change does.
- CodeRabbit
- An AI code review tool that analyzes pull requests, summarizes the changes in plain language, and surfaces suggested fixes inline so human reviewers can move faster.
- Atlas (CodeRabbit)
- A CodeRabbit feature that reorganizes a pull request's diff into logical layers — data shape, business logic, tests — and adds contextual AI summaries alongside the code as you scroll.
- Ask mode
- A mode in AI coding tools where the agent only asks clarifying questions and discusses the work instead of editing files, used to nail down requirements before any code is written.
- Plan mode
- A built-in mode in tools like Claude Code, Codex, and Cursor that produces a structured markdown plan — phases, todos, verification steps — before the agent is allowed to start changing code.
- Prototype mode
- A working style where the agent is told to build only the front-end with mock data — wireframes, navigation, dummy JSON — so the interface can be validated before any backend logic is written.
- ASCII diagram
- A diagram drawn with plain text characters that an agent can produce instantly inside a chat or markdown file, useful as a quick wireframe or architecture sketch.
- Lint
- An automated code check that flags style violations, syntax errors, and likely bugs without actually running the program, typically run as part of a build pipeline.
Things they pointed at.
Lines you could clip.
00:15
“I went to all the major skill libraries... and distilled all the key ideas down into a couple of prompts, skills, and patterns that you can reuse on every project over and over.”
06:42
“I don't rely heavily on spec-based systems. I just go with something a little bit lightweight and bespoke myself.”
12:32
“I think the best system is going to be the one you end up building yourself.”
13:09
“When you do create a skill, it's only because the agent has messed up in some way or you want to give it very bespoke information about your codebase.”
14:45
“Your agent harness, your set of skills that has been built up over time working with a particular codebase — that's how you really differentiate as a software developer.”
Word for word.
metaphoranalogystory
00:00So I went to all the major skill libraries, Gary Tan, superpowers, Matt Pocock, bMAD, everything Cloud Code, GSD, OpenSpec, and more. Essentially, what I wanted to do was distill all the key ideas down into a couple of prompts, skills, and patterns that you can reuse on every project over and over, and these are the ones I've settled on after almost two years now of working with agents.
00:24We're also gonna talk about how the most powerful skill system is built and why you're not gonna find it in someone else's repo. Also this week, our sponsor CodeRobbit just released a wicked new tool for a code review. More on that later.
00:35So skills are just part of the entire agent harness that we use to build our software. Skills are just natural language prompts. What differs is you put them in a special file called a skill dot m d.
00:47You've got some front matter in there, which is some extra information like the name of the skill and the description. And this is always loaded by the model, so it has an idea of what skills it has capable of using. You can have scripts, reference material, assets all bundled into your skills folder.
01:04So recently, what we're starting to see trend is skill libraries. So we've seen some really popular ones from Gary Tan, Afan Mustafa, Matt Pocock, Ali Asmani. All these guys have been working in the industry for many years and have been pooling their approaches and thought processes into collections of skills, which they're sharing with the rest of the community.
01:22If you look at GitHub for any of these skill systems, you've seen they're seeing huge growth. If you look at something like Everything Clog Code, that's up at a 183,000 stars.
01:31For context, there have been some huge open source projects that have been on the go for twenty years that don't have anywhere near that many stars. So having studied, used, and reviewed all these different skill library, you can really see that there really is a lot of common denominators. Let's take a quick look at some of the major repositories and see what the commonalities are.
01:50So Adi Asmani is from Google. He's got a great blog that's worth following. What he advocates for is a simple set of skills based around creating a spec or specification for what you want to build.
02:02So you have a chat with an agent and decide exactly what's going to be built. Then you create a plan so the agent thinks about what how it's going to build out the specification or idea that you have. It builds it and builds incrementally one slice at a time.
02:15Once the build is finished, it gets tested to make sure it adheres to the plan and the spec. Optionally then, you can review the code before it gets merged. You can run code simplification prompt to ship to production.
02:27So this is basically just one iteration of development all encapsulated into six or seven prompts.
02:34Mac Pocock has been on the go for years, a fantastic TypeScript developer and AI engineer. He is advocating for real simplicity. In Matt's skills, see a lot of similarities to what Adi has developed.
02:45We have a diagnose, which is very similar to a discuss or specify. I do like the grill with doc skill. Matt is a big believer.
02:52Have a grounding and understanding in the domain model that you're working in and not having to repeat that every single time because you remember our agent has a certain amount of context window, and you wanna load some of that context and understanding of the project. So grill with docs is one that's worth checking out.
03:06Again, we see some commonalities around test driven development. All of the frameworks advocate for some level of test driven development. It's the idea that you've got tests in place so that if your agent goes off and writes new code or does something else, that you can run a suite of tests to make sure that nothing that you had previously built ends up being broken.
03:24It can be hit and miss. With a of AI models, they actually cheat their way through testing, but it is one extra step to make sure that we're not breaking existing code as we move forward. Same as Adi Asmani, we have the two issues, which is basically, again, just breaking down a bigger project into a smaller vertical slice that the agent can handle.
03:42You don't want the agent taking on too much in the one go without actually verifying it to make sure that they built exactly what needed to be built. And then another one that I see that Matt has added is prototype. So it's the idea that you actually flesh out a design before you build it out, and I'm a big believer in this.
03:58Anyone who has taken my course knows that I'm a big fan of a design mode or a prototype step. The idea here is that you just tell the model that you're going to implement the front end of the application, not the back end. Because once we get into the back end, it starts to slow the agent down.
04:12And then actually passing that prototype to the agent gives it a much better sense of what it needs to build in the back end. So doing this as an upfront step really saves some time. And again, this isn't a new idea.
04:23We've been doing wireframing and prototyping for the last thirty plus years. This is just the agentic approach. So Gary Tan is the CEO of y Combinator.
04:33So Gary has a much more opinionated skill stack, and there is a lot to learn from this. Personally, it's a bit too overengineered for my liking.
04:41But if you look at any one of the individual skills, there's a lot of interesting things to learn from, particularly his skill around office hours. Hours is really unique. It's like the idea that we sit down with the Y Combinator CEO, and he asks us six forcing questions about our startup idea.
04:57I actually think a big differentiator now when anyone can build quickly is actually knowing what to build and what to focus on. And then we have everything Claude code by Affen. Now don't be worried.
05:06This relaxed skill system will work for any different kind of agent. So of all the libraries that I've shown, this one is probably the biggest. It's at about a 182,000 stars and a 170 contributions.
05:18It is pretty huge in terms of what it offers. It looks after memory, continuous learning, how to run verification loops, sub agent orchestration. It has a heavy focus on security.
05:29If you want to deep dive into what an extensive harness might look like, it's worth taking a look at all the different skills that it's got in there. And just a quick note on all the various different spec libraries. There's a lot of overlap between the skill systems that I showed you and, of course, these spec based libraries, and I've covered a lot of them on the channel previously.
05:48BMAD is very enterprise level. It follows the path of a business analyst, a product manager, a senior architect, all working in party mode to send to figure out what you need to build and make sure it follows a strong software development life cycle process.
06:03So if you're at an enterprise level, it's worth checking out BMAD. Superpowers is a little bit more lightweight.
06:08Of all of them, I think I actually like superpowers the best. I've had some good results with it, but I'll be honest, I don't rely heavily on spec based systems. I just go with something a little bit lightweight and bespoke myself, and we'll talk about that in a second.
06:20Working with enterprise development teams, one of the biggest complaints I've gotten in the last year is the amount of code review that needs to be done. Thousands of lines if you let it get out of hand, but I highly recommend you make your commits a lot smaller to be a lot nicer to your team. But we still have to review a lot of this code, and that's become a bottleneck.
06:38So if you've been watching the channel for a while, you know I'm a big fan of CodeRabbit. So what I'm most excited about is just in the last couple of days, they've released Atlas, and this really solves a big pain point for me. I've got a project here that I'm working on, and we have a pull request.
06:51If you don't know what pull request is, I've got a great video on git, a couple of videos back you can check out, and I'll link to that in the description. But essentially, either an agent or somebody else in my team has gone and created a load of code, and they've submitted it for me to review before I actually add it into the main code base.
07:07So normally, what I have to do is go through the commits and go through all the merged code. And generally, this is quite a painful step because you're just looking at these side by side diff views that we're all familiar with. Basically, a side by side diff, here's the original, and here's what changed.
07:21But when I'm dealing with so many pull requests across so many different repos, this really starts to fry my brain a little bit. So CodeRabbit was really paying attention to this and came up with something that I think is really, really useful.
07:33So essentially, when I click that little review button, here's what I get instead. But instead of a big long alphabetical file list, it breaks it down into layers. So to me, the layers are basically, okay, well, what's the new data shape?
07:44And we can see that here. Then what kind of business logic is gonna consume that data shape? And then, you know, what's the testing around it?
07:51I wanna look at this change in patterns. So on the left here, I get that structured navigation and the layers of the diff, then I get the traditional diff in the middle. And then on the right, I get these little AI summaries of exactly what's going on.
08:04And as I move to the code, they actually change and update based on what I'm looking at. So here, it gives me an explanation of exactly what's happening at each stage. And to be honest, even if you're a beginner developer, this is really useful for helping you learn the code and the patterns that AI might be generating so your skills don't atrophy and that you actually improve as a developer.
08:23And then what's even cooler is I can go ahead and chat with any one of these different comments or the pull request in general. So it handles everything native GitHub review can do as well. So I can add my comments here, and when I'm finished, I can just go and submit my full review, comment approve, or request changes.
08:40So Atlas just came out in the last couple of days. I highly recommend you check it out, and it's free for a limited time, so get stuck in. Check out the link in the description down below.
08:49Okay. So we've taken a look at all the various different popular skill systems and stacks. Let's compile them together to show you the best pattern and skill pattern you can use to build out your projects.
09:00And this is going to be super simple. I'm not introducing you to another repository you have to follow. It's just a set of patterns and a way of thinking that if you can imprint, you're gonna be getting away with 90% of what all of these systems offer.
09:13So the first thing you're gonna do is go into ask mode. You can get ask mode in cursor in Clog code, or you can set it up as a little skill yourself. So this doesn't need to be a skill.
09:22All you need to do is basically ask your agent to interview you about the project that you're going to create. Next up is you wanna create some kind of a prototype. You can ask the agent to to produce an ASCII diagram.
09:32They do it really quick, and it'll give you a quick wireframe, fastest way to do it. Or you can just chat to the agent and say, hey. Let's go into design mode.
09:40I only want you to work in the front end, not in the back end. I want to design the wireframe of my application. So here's a quick example of design mode.
09:49So you basically just wanna let the agent know we're in prototyping mode, develop front end only, we're mocking up the interface, use dummy JSON to represent any back end data, link all components for navigation, make buttons responsive, don't connect to back end logic. So essentially, you're stopping the agent from creating a complicated back end that it has to support.
10:09We just wanna figure out the front end. We're gonna do the back end later. So sometimes if it's a basic feature or we're just doing any kind of back end logic, we can actually skip prototyping.
10:17We sometimes have a strong idea of what we need to build, so you don't need to do it in every single step. So both Clog code, Codex, and Cursor have their own vanilla plan mode, which is really quite powerful, and I don't think you need any kind of skill system around this. In the case of Cursor here, and it's the same if you're using Clog code or Codex, It's basically gonna create a document as a markdown, breaks it down into various different phases so it knows what it should work on first, which is important.
10:46It's very similar to how those other frameworks would shard or split the project into multiple different parts. And then it creates a list of to dos to work through. And it sets out all these different verification steps naturally without you having to build any kind of skill around this.
11:01This is something we needed to do for ourselves via skills and processes before, but now a lot of the modern agents are doing this for us. Once the build phase is completed, we're going to want to test and verify exactly what we wanted to get built was built. And again, this is something that's baked into the plan mode of many agents now.
11:19It's going to run a lint and build test to make sure that everything compiles and works okay. Then what you can do is get the agents to use Playwright or the browser mode, which is in cursor or in claw code to basically test the application to make sure that it's all working fine.
11:34Now this is kind of hit and miss. The testing that agents do doesn't really catch what you want it to do. Inevitably, the test phase is still what we call a human in the loop phase where via some kind of a smoke test where you're gonna click through the process yourself to make sure that everything works okay.
11:49Now one thing a lot of the other frameworks talked about was test driven development. If you want that to be part of your workflow, you just include that in the planning stage. Just say, want to include test driven development, and it will start to implement and build tests as it's writing the code.
12:04So that's pretty much it. Research, prototype, plan, build, and test. That's your kind of iteration loop.
12:09Essentially, this is all you need to get your software built, but there's a few extra steps, and that is the polish step. Adi Asmani has a skill which is called simplify code. So essentially, that means you're getting an extra agent to run through the code.
12:21In this case, you might have used Opus or a Anthropic model to build the software. You might use GPD 5.5 or something like that to basically work through the code and give its opinions.
12:35I think the best system is going to be the one that you end up building yourself. That's for a couple of different reasons, and I'll explain why. So first, I'd start with just natural language prompting, the kind of framework that I just showed you.
12:47You're just using your own agent patterns to work with the agent. Use the built in ask mode, the build mode, the plan mode as much as you can, and just rely on the native capability of your mind and also the harness. When you do create a skill, it's only because the agent has messed up in some way or you want to give it very bespoke information about your code base or your process that you want to carry out and when you want that to be a very repeatable process.
13:14Also, you want to be rewriting your skills to be as simple as possible, maybe even just a few short paragraphs. There's no need for tons of extra information, which is going to bloat your context window and confuse the model. Next up, you're just gonna work with that very simple skill alongside the agent harness that you're using.
13:29Understand where it works well and where it doesn't, then manage for those edge cases you feel like the skill is missing. In traditional software, we have something that's called the software development life cycle, and that encompasses multiple different disciplines.
13:42Now we're looking at something that's like agentic development life cycle, and a big part of that is managing your harness and also skill management, particularly when you work across multiple different developers and large organizations. Let's say you develop a skill that you feel is useful.
13:56How do you share and organize that skill with other people in your organizations? Skills.sh from Vercel does a good job of allowing you to store your skills in private repositories, being able to update them, store them, and share them as you see fit.
14:10Skills in some ways are essentially just documentation, and we've all experienced the scenario where comments go out of date, documents go out of date. You're going to have to spend as much time updating these skills and keeping them current, so you need to be very careful about what ones you introduce.
14:25Are they absolutely necessary, or are they just going to cause confusion to the model at a later point? This is a whole new skill set, if you will. So inevitably, the best skill system and the best harness is going to be the one you develop over time for you.
14:38I think this is going to be how you really differentiate as a software developer. Your agent harness, your set of skills that has been built up over time working with a particular code base. If there's one skill that you absolutely can't live without, please share it in the comments so I can learn and everybody else in the community can learn as well at the same time.
14:56So hopefully, was helpful. Instead of introducing you to yet another skills library that you have to test and try, I kinda wanted to bring things back down to earth, give you the feeling that you weren't losing your mind in keeping up with all of these systems, and understanding that it's really just some simple development loops that we've been practicing and using for the last thirty or forty years of software development that you can rely on.
15:18A lot of these libraries, a lot of these skills are replicating that same approach. That really starts to that you're working within. If you found this useful, hit the subscribe button.
15:28It means you'll get more videos like this in your feed, and I look forward to seeing you next week.
The Hook
The bait, then the rug-pull.
Rob Shocks did the homework so you don't have to. He spent almost two years working with agents, surveyed every major skill library in the ecosystem and came back with a single decision rule: five steps, no repo to clone.
Named ideas worth stealing.
09:11list
The Simple Skill Stack
- Research
- Prototype
- Plan
- Build
- Test
- Polish
The 5 (+ 1 optional) step agentic development loop. Research = ask mode interview. Prototype = design mode frontend only. Plan = native plan mode. Build = vertical slices. Test = automated + human. Polish = simplify pass with different model.
Steal forSession templates, morning launcher, agent kickoff prompt
00:35model
Agent Harness Architecture
- Planning
- State Management
- Memory
- Tool Runtime
- Skills
- Evaluators
- Reasoning Engine (LLM)
Skills are one component inside the full agent harness, not the whole thing. Common mistake: treating skills as the harness itself.
Steal forJoeFlow Sessions as a harness cockpit — each layer maps to a Sessions feature
23:02concept
Agentic Development Life Cycle (ADLC)
The agentic equivalent of SDLC. Includes skill management and harness management as new disciplines alongside traditional dev stages.
Steal forContent angle: The ADLC is the new SDLC — MCN+ positioning piece
04:40concept
office-hours (Gary Tan)
A skill that forces 6 YC-style questions about your startup idea before building. Rob rates it the best individual skill across all libraries.
Steal forChef prompt pattern: force 6 questions before any build session starts
02:48concept
grill-with-docs (Matt Pocock)
Pre-loads domain vocabulary, framework terminology, and ADRs into model context at session start. Prevents agent from drifting outside your project language.
Steal forJoeFlow CLAUDE.md or session-start prompt pattern
09:46list
Design / Prototype Mode
- Frontend only, no backend logic
- Use dummy JSON for all data
- Link all components for navigation
- Make buttons responsive
- Do not connect to backend logic
Isolated frontend-first pass before any backend work. Agent builds a clickable wireframe with mocked data, giving a clear target for the backend phase.
Steal forSessions panel: add a Prototype session type that prefills this constraint set
How they asked for the click.
25:00subscribe
“If you found this useful, hit the subscribe button.”
Clean single-line ask at the end. No newsletter pitch, no sponsor repeat. Low-pressure.
Visual structure at a glance.
