Look, I was getting tired of jumping between AI coding tools like some kind of digital nomad with commitment issues.
One day I’d be in Cursor for quick edits.
Next day trying out Kiro for its spec-driven magic.
Then back to Claude Code because I actually like working in the terminal (yes, I’m that developer).
Each switch meant losing context.
Starting over.
Explaining my project again like I had coding amnesia.
It was exhausting.
Then I had a thought.
What if I could get Kiro’s best features without being locked into their platform?
What if I could build the same structured workflow using Claude Code’s slash commands?
Turns out, I could.
And it works better than I expected.
Why Kiro IDE Changed Everything
Kiro didn’t just give us another AI coding assistant (because we clearly needed the 47th one).
They gave us a philosophy.
Spec-driven development instead of “vibe coding.”
Instead of throwing prompts at AI and hoping for the best (the developer equivalent of throwing spaghetti at the wall), Kiro makes you think first.
It takes your messy idea and forces it into a proper specification.
Then it breaks that spec into actual tasks.
Then it builds each task methodically.
The agent hooks were genius too.
Every time you save a file, hooks check your work.
Tests get written automatically.
Documentation gets updated.
Security scans happen in the background.
It’s like having a senior developer watching over your shoulder.
But not in the “why didn’t you use a semicolon here” annoying way.
This structured approach solved something I didn’t even know was broken.
Most AI tools make you feel productive but leave you with a mess.
Kiro made you actually productive and left you with maintainable code.
The difference between feeling good and being good.
The Claude Code Alternative
Here’s what most people don’t understand about Claude Code’s slash commands.
They think they’re just shortcuts.
Quick ways to type common prompts.
They’re wrong (but in a really understandable way).
Slash commands are programmable workflows.
You can build entire development processes inside them.
And unlike Kiro, you’re not locked into someone else’s platform.
You own your commands.
You can modify them.
You can share them.
You can use them anywhere Claude Code works.
Which is everywhere (unless you’re still coding on a toaster, in which case we need to talk).
The token efficiency alone makes this worth it.
Instead of writing the same context-heavy prompt over and over, you write it once.
Save it as a command.
Reuse it forever.
Your conversations stay focused.
Your costs stay low.
Your workflows stay consistent.
Building the Kiro Workflow Commands
I started by studying what made Kiro actually work.
The actual mechanics.
Turns out, Kiro’s magic comes from one thing.
Enforced structure.
Requirements before design.
Design before implementation.
No skipping steps.
No “I’ll figure it out as I go.”
So I built four commands that enforce the same discipline.
The Add Feature Command
/add-feature user authentication system
This is where everything starts.
Give it any rough idea and it forces you through three phases.
First, it creates user stories in EARS format (Event-driven Acceptance Requirements Specification for the nerds).
Won’t move forward until you approve the requirements.
Then it builds comprehensive design documentation with Mermaid diagrams.
Won’t proceed until you sign off on the architecture.
Finally, it creates numbered task lists with requirement traceability.
Every task connects back to a specific requirement.
No orphaned code.
No feature creep.
The Steering Documents Command
/create-steering-docs
This solves the context problem that kills most AI projects.
It analyzes your repo and creates three persistent knowledge files.
Product overview and target audience.
Technical stack and development guidelines.
Project structure and architecture patterns.
Now Claude remembers your decisions across sessions.
No more re-explaining your tech choices every conversation.
The Start Task Command
/start-task user-authentication
Here’s where the magic happens.
It reads all your specification files for context.
Executes ONE task at a time.
Marks tasks as in-progress, then completed.
Waits for your approval before moving forward.
No runaway AI building half your app while you grab coffee.
The beautiful part?
You can’t skip phases.
You can’t bypass approvals.
You can’t execute tasks without specifications.
The commands literally won’t let you.
Real-World Implementation
Clone the repo.
Copy the .claude folder to your project or home directory.
Run Claude Code.
Four new commands appear instantly.
I tested this workflow on a React authentication system.
Here’s exactly how it went.
Started with /add-feature user authentication with signup and login
Claude generated comprehensive user stories.
“As a new user, I want to create an account so that I can access the application.”
Each story got acceptance criteria in EARS format.
Event: User submits valid registration form
Action: System creates new user account
Result: User receives confirmation and can log in
I approved the requirements.
Claude moved to design phase.
Architecture diagrams with Mermaid.
Component breakdowns.
Database schemas.
API endpoint specifications.
I approved the design.
Claude created 23 numbered tasks.
Each task referenced specific requirements.
Each task had clear success criteria.
No ambiguity.
No guesswork.
Then I used /start-task user-authentication to begin implementation.
Claude read all the specification files.
Executed the first task only.
Created the user model with validation.
Marked it in-progress (~).
Waited for my approval.
I said “looks good.”
Claude marked it complete (x).
Asked if I wanted the next task.
The whole flow took a few minutes from idea to first working code.
And the output quality?
Better than anything I’d built manually.
Because every line connected back to a requirement.
Because every component fits the approved architecture.
Because I couldn’t skip steps even if I wanted to.
Performance-wise, it’s no contest.
No IDE startup time.
No platform switching.
No subscription requirements.
Just pure workflow efficiency with actual guardrails.
Ready to Try It Yourself?
Here’s the thing about developers.
We’re skeptical by nature (occupational hazard).
You’ve read this far, but you’re probably thinking “sounds good in theory, but does it actually work?”
Fair question.
I built this because I needed it.
Not because I thought it would make a good article.
So I’m putting my money where my mouth is.
The entire implementation is open source on GitHub.
No paywalls.
No “sign up for my newsletter first” nonsense.
Just working code you can use immediately.
GitHub Repository: https://github.com/AshExplained/ccspecdev
Clone it.
Test it.
Break it (please try to break it).
Here’s what I want from you.
Try the workflow on a real feature.
Something you’re actually building.
Not a toy project.
Use /add-feature with your actual requirements.
Go through the full Requirements → Design → Tasks progression.
Execute some tasks with /start-task.
Then tell me what sucks.
What’s missing?
What would make it better?
What assumptions did I get wrong?
Open an issue.
Submit a pull request.
Roast me in the comments.
All feedback is good feedback.
Because here’s what I learned building this.
The best workflows aren’t designed in isolation.
They’re battle-tested by real developers solving real problems.
Your problems might be different from mine.
Your workflow preferences might clash with my assumptions.
That’s exactly what I want to know.
So we can make this better.
For everyone.
The Real Win
Look, Kiro is impressive.
The team built something genuinely useful (no shade, seriously).
But sometimes developers don’t want another platform.
We want better workflows.
We want structure without constraints.
We want power without lock-in.
These four Claude Code commands give you Kiro’s methodology without Kiro’s limitations.
You get the spec-driven development.
You get the enforced phase progression.
You get the requirement traceability.
You get the structured approach to AI coding.
But you keep your freedom.
You keep your tools.
You keep control.
And you get true ownership of your workflow.
Try the commands yourself.
Make it yours.
Because the future of AI development is about building the right workflows.
And now you can build those workflows anywhere.