I Built a Free CLI Tool That Streamlines AI Development in 2 Hours
May 17, 2025
I built a free CLI tool in a couple hours to make AI development more repeatable and less brittle. It scaffolds an SDLC-driven workflow using modular markdown-like outputs and prompt chaining so outputs don’t break as models improve.
What problem this solves#
- Keeps engineering quality in AI projects by treating task creation like a software SDLC, not a marketing bullet.
- Moves beyond hype around “vibe code” by focusing on concrete artifacts (PRDs, architecture, tasks, tests) that survive model updates.
- Bridges between fast AI prompts and durable project structure via modular, self-healing patterns.
How this AI SDLC CLI works#
- Self-contained workflow that prompts you for each SDLC step and builds the project structure accordingly.
- Uses prompt chaining: each step feeds into the next, preserving context and decisions.
- Keeps outputs stable via a file-tree and markdown-like docs, while letting the model improve the underlying reasoning over time.
Core concepts and flow#
- Phases (order roughly followed in the tool):
- Idea
- PRD (Product Requirements Document)
- PRD + Architecture / System patterns
- Tasks (and placeholders for tests in the future)
- Optional: Tests (currently removed in the initial version)
- Architecture patterns included (Python and TypeScript focus initially):
- Singleton, Factory, Facade, Observer, Strategy, Decorator, Repository, Dependency Injection
- Python-specific typing and tooling patterns
- System patterns:
- File-tree awareness, filtering noise, proposing target structure
- Self-healing: if a pattern already exists, adapt rather than overwrite
- Output artifacts:
- Rules and decision rationales (why a pattern was chosen)
- Task lists with checkpoints and code snippets
- Reference to dependencies, paths, and example scaffolding
- Scope and tech:
- CLI-based, Mac-only initial rollout
- Python and TypeScript support planned
- Free to use
How to use (quickstart)#
- Install and initialize
- CLI installation:
- pip install AI SDLC
- Initialize and start the workflow (example):
- ai_sdlc init
- ai_sdlc idea "Refactor authentication flow for better modularity"
- What happens next
- The tool creates a left-hand side project layout with:
- doing
- done
- prompts
- You then provide the idea, and the CLI generates the next set of files and prompts for each subsequent step
- Example file tree after init (illustrative)
- Code block:
.
├── doing
│ └── (current active work)
├── done
└── prompts
├── prd.md
├── arch_and_patterns.md
├── tasks.md
└── tests.md (optional)- Example flow (high-level)
- Idea -> PRD (captures problem, success criteria) -> PRD + Architecture (system patterns, file-tree proposal) -> Tasks (with examples, dependencies, paths) -> Tests (omitted in this first version)
- Each prompt uses the previous step as input to provide continuity
What’s included in this first release#
- Self-healing rules:
- If a project already has a pattern, the tool updates it instead of replacing it
- Checks the current file tree to guide architecture decisions
- Pattern library:
- A set of common architectural patterns (listed above) that the tool can scaffold and reason about
- Language support in scope:
- Python and TypeScript examples and scaffolding
- CLI-only (for now):
- No GUI, no MCQ bells and whistles; focus on solid, repeatable scaffolds
Limitations and current scope#
- Tests are temporarily minimized/elided in this initial version
- Mac-only environment in this iteration
- Not a finished product; a fresh build with user feedback will drive improvements
Takeaways and practical tips#
- Treat AI-assisted development as a lifecycle, not a one-off prompt
- Use modular markdown-like docs to anchor long-term stability as models evolve
- Chain prompts across SDLC steps to preserve decisions and rationale
- Start with architecture patterns and a concrete file-tree scaffold to gain immediate traction
- Build the tool to adapt: prefer self-healing rules that adjust existing patterns over overwriting them
Next steps and ideas#
- Expand tests to cover unit, integration, and behavioral tests within the prompts
- Extend language support beyond Python and TypeScript
- Add richer examples, more patterns, and deeper analysis of architectural trade-offs
- Consider adding a “move fast with safeguards” mode that surfaces riskier design choices for human review
Links#
- Related tooling references: Jira, Notion, Linear discussed as context for workflow integration
- Cursor Memory Bank (inspiration for the self-improving approach)
Transcript
So, I've spent the last few hours building tools because I didn't even mean to, but there's a big problem that I and a bunch of people in our community run into, and it's on both ends of the spectrum. So, when you hear the word vibe code, you have seniors who really don't like that term because it's a trick where, hey, I just spent like 15 years of my life getting good at this craft and now all of a sudden everyone who used both thinks that they're a dev. No. And then they don't spend the time to learn how to use them. But that's also because they already have a ton of leverage in the way that they're working. And then on the other side of the spectrum for this the newbies, they think that the dopamine hit from the marketing site that they made with Bolt means they're an engineer. So it sucks on both sides. But that said, I think the problem that you solve for is like how do you make markdown files? How do you make things that won't change as models get better? How do you make those really good such that they're modular? I just say it's literally like markdown files and some scripting. And so I was working on Echo, my B2B content creation platform. It will be B2B eventually. Right now it's just for me, but I'm working on that and I realized the patterns that I keep doing and wanted to solve for them. So as I was running it, I said, you know what? I'm just going to ask 03 how I would scaffold something like this. And I wrote down all the issues that I'm having as well as the people in our community are having and started getting to work on what a system would look like. So it started with some research with finding out how OpenAI ships, how different people ship. You have agile, you have waterfall, you have shape up, you have all these things. You have a traditional software development life cycle. And some of these pieces, they just get washed away when you're using tools. And then everyone thinks that if they get the PRD prompt that it's going to be perfect, but that's not the case because you actually have to use your brain ahead of time to figure out what the problem is. And then you write a pitch and then you poke holes in that pitch. Typically in my career when I as a product manager when I was time as a PM, my whole life was just writing technical specs and those take a lot of thought. But long story short is I figure I could probably prompt around this and use sequential thinking and some prompt chaining to to help with this because I do find that a lot of the tools they just nail one part like people like augment for bug hunting but it's really a symptom of fact that they had code generated that they don't understand. So, you really wouldn't even I don't know like you'll still always have bugs, but I think it's heightened right now. And then people will reach for anyone any number of one of these tools to go and try to get stuff done. And that's fine. I'm not saying don't use any tools, but I'm pretty excited about this thing that I just made because what I found is you don't get depth on task creation if you don't understand what's going on. And so you can't get depth on task creation if you don't have the file tree, if you don't have the architecture, if you don't have a technical spec. All these things that would go before writing a Jira ticket. Sorry if you use Jira or if you use notion, whatever. You get what I'm saying? Linear, all these steps would happen before that. And so I'm trying to emulate that. And I've spent I don't know two hours fiddling around with this idea. I'll have to get your guys' take on it. But the idea being that you'd have these different prompts and what won't change is that models will get better. So instead of having templates of expected outputs, all these different things, you can basically just have a prompt for each one of the steps in the software development life cycle. So I'm starting with idea PRD PRD plus architecture system patterns which then takes everything that came before it checks if we do already have a pattern in the project for existing projects. If we don't then it'll create a rule. So it's a self-healing self-improving thing and then eventually you get a tasks prompt which will have a bunch of the stuff in it. So it'll have like examples and showing you the different markdown tasks as well as actual snippets because relevant paths, snippets, packages, dependencies, those are the same thing. Languages, all those things matter. And then also baking into the architecture having different popular architectures. So using things that everybody has, this will be for Mac only and Python and TypeScript to begin with. But when it comes to having system patterns, I can put in, hey, here's a check where you need to go and run a file tree and ignore all the stuff we don't want to see. So that way we can know like where we're at so we can make a good recommendation. And then you have a proposed file tree of where we want to go. And then based on your response, you can either say yes or no. And then it'll explain why it chose the pattern that it's going to do. It will give you the technical decisions around it. And then it'll also it has a list of all the different patterns that are popular for both Python and JavaScript. And a lot of these apply to other languages, but I just in terms of having the like specific code in here as examples, I just picked the two languages that I use the most. It has singleton, factory, facade, observer, strategy, decorator, repository, dependency injection, and then Python specific ones, types, like all this stuff basically. And so I'm pretty amped on it honestly. I'm calling it the AI SDLC, so software development life cycle. and it will be a CLI tool. So essentially you have a couple commands, but I just want this thing and I think it'll be really helpful and it'll be free. But the way that it'll work is let me just see here. So you'll do pip install AI SDLC and then you'll initialize it. It'll build out the folders on the lefth hand side. So in my case, I'm running something similar to this now with this project and I realized like I need to systemize it for myself and I was like I should share and get feedback. But in here it is you have doing and done and then prompts. So doing would create this is not it. These are the folder structures. And then in the actual version that I'm making over here, you would have a much prettier looking thing. All right. So once you've initialized it, then you type in your idea. So if it's a refactor, you type that in and then that'll go and create the next set of files for doing. And it has each step with the name of the idea thereafter. And then each prompt just has a previous step as a prompt variable that passes in the output from the previous one. So for this first version, because I made this in a couple hours, it won't have any sort of yes, no, I don't want MCPS. It's CLI only. And but you could still just go delete it and then rerun the step. But yeah, you'll have idea PRD refactor or sorry PRD prd plus architecture system patterns which takes in the thing from before it checks to see what's going on then writes a rule. If there is no rule it'll write the full rule. If there is a rule it'll modify it based on any changes that you're making to your codebase. Then you get the tasks and then tests. I'm removing these last two for now, but tests will be looking against the markdown checkbox list of things that you've done so far and then deciding what needs tests. That'll be inclusive of unit tests, integration tests, and behavioral tests. And what's so great about that is it also just has pre-specified libraries and stuff. I just try to put all the stuff that I know works for me. And then you'll have a custom rule. So, this will be able to work in cursor. So, a lot of this is inspired by memory bank. We'll see how it goes. But, I'm excited about it. I think it'll be dope. That's it for this video. And if you found any sort of help by just listening to me run the motor, then make sure you subscribe to the channel because I make a bunch of these videos. Make sure you like the video. And if you want to join our community of people way smarter than me, then you can check that out, too. We just hang out and yap. Lastly, yeah, if I'm not like thinking of anything in here, let me know.