Introduction: Where I Am Now
I’ve been writing code for a few years now — long enough to ship real features, wrestle with edge cases, and feel the weight of decisions I made too quickly. But also long enough to know I still have so much to learn.
Lately, I’ve felt the quiet urge to pause — not to quit, but to rebuild. Not just the software I’m working on, but how I think as an engineer. I want to become the kind of developer who designs with intention, from the inside out.
Somewhere between pushing through projects, learning new tools, and trying to land the next opportunity, I noticed something: I was carrying patterns I never consciously chose. Ways of thinking, planning, and building that I inherited from urgency, burnout, or just trying to keep up.
So this season, I’m slowing down — and rebuilding my software mindset from the ground up.
Using the software development lifecycle as a guide.
Not to prove I’ve mastered the craft — but to grow deeper roots within it.
Why I’m Doing This Now
This isn’t just about becoming a “better developer.” It’s about becoming a more intentional one.
The truth is, this rebuilding season didn’t come out of nowhere. It followed a long stretch of uncertainty — emotionally, professionally, and personally. I was building, shipping, trying to stay afloat — but something felt disconnected. I had ideas, but not always clarity. Progress, but not always peace.
Then one night, I found myself rewatching Marvel’s Black Panther and Black Panther Wakanda Forever — and something hit different.
Shuri’s lab wasn’t just futuristic. It was sacred. Every piece of tech in that world was grounded in identity, legacy, and care. That planted a seed in me:
What if I built something like that?
What if I built my own GRIOT?
What if software could feel like an ancestral companion — not just a tool, but a guide?
That spark led me to what would become GRIOT — a system inspired by the griots of West Africa, reimagined through modern tech. Part journal, part guide, part memory keeper.
I’ll go deeper into what GRIOT actually is in a later post. But for now, what matters is this:
I knew I couldn’t build it the way I built past projects.
If I wanted it to be grounded and emotionally intelligent, I had to slow down and design with structure and intention.
This wouldn’t just be an app — it would be a living system designed to listen, reflect, and evolve with you. Rooted in memory, voice, healing, and rooted presence. A kind of digital griot — part journal, part mirror, part AI reflection partner.
And if I wanted it to feel that sacred, I couldn’t just code it like every other project. I had to build it differently — with structure, clarity, and rooted presence.
That’s why I’m doing this now.
To rebuild my software mindset through the lens of meaning.
To grow not just as a coder, but as a systems thinker with a rooted voice.
To make sure that the way I build reflects what I truly care about.
What Sparked This Journey
Around the time I started designing GRIOT, I kept feeling this tension — between what I was building and how I was building it.
I knew I wanted GRIOT to be thoughtful, grounded, meaningful. But my development process still carried old habits: rushing through design, skipping over architecture, figuring things out as I go. That tension made me pause and ask:
What if I gave this project the structure it deserves?
What if I rebuilt my mindset alongside my codebase?
That’s when I decided to revisit the foundations, not just in theory, but through lived application. I enrolled in Kurt Anderson’s Udemy course titled Software Engineering 101: Plan and Execute Better Software, and one of the early concepts that stood out was the WRSPM model: World, Requirements, Specification, Program, Machine.
I’d seen models like this before, maybe skimmed them in college, but I had never applied them with this level of care. This time, it wasn’t just about passing a test or designing a mock system. It was about crafting something real, personal, and alive.
WRSPM gave shape to the vague intuitions I had about GRIOT.
It helped me ask better questions like:
- What world does this system live in?
- What does that world need?
- What does this system guarantee in response?
Instead of jumping into UI or feature lists, I was slowing down — thinking like a systems designer. Aligning code with context. That shift changed everything.
This wasn’t just another course. It was a mirror — and an invitation to rebuild the way I think.
Why The SDLC
When I first started coding, I treated the software development lifecycle like a checklist —something academic.
Requirements? Sure. Architecture? Maybe. Testing? Only if something broke.
I was more focused on building fast than building well.
But now, in this season of rebuilding, the SDLC feels less like a rigid process and more like a compass.
It gives me a structure to think clearly.
A rhythm to design intentionally.
A way to align vision with execution — one layer at a time.
Instead of skipping straight to features or UI, I’m learning to slow down and move through each phase with care:
- Gathering meaningful requirements
- Designing architecture that reflects real human needs
- Writing modular code I can trust and grow with
- Testing not just for bugs, but for clarity
- Choosing a development model that supports reflection, not just iteration
The SDLC is helping me rebuild my mindset as much as my codebase — and that’s what this series is about.
Not just what I’m building, but how I’m building it. And who I’m becoming along the way.
What GRIOT Is and Why It Matters
GRIOT isn’t just another app idea. It’s a response to something deeper I’ve been feeling for a long time — the need for systems that don’t just track what we do, but support who we’re becoming.
At its core, GRIOT is about reflection. About memory. About presence.
It’s a space where your thoughts, emotions, voice, and patterns can live — and speak back to you with gentle insight.
A kind of digital griot: part journal, part memory keeper, part AI guide.
The name comes from the West African tradition of griots — oral historians, poets, and truth-keepers. In many cultures, the griot is not just a storyteller, but a guardian of memory and identity. That concept stayed with me. What would it mean to build a system that honors that role in a modern, personal way?
That’s where the idea for GRIOT began — not as a product, but as a companion.
Something that listens. Remembers. Reflects. And helps you stay rooted in your own truth.
And in a world full of noise, distraction, and performance, I think that matters more than ever.
What This Blog Series Will Cover
This series is my way of thinking out loud — rebuilding my software mindset, one phase at a time.
I’m not writing as an expert. I’m writing as someone returning to the fundamentals with fresh eyes, applying them to something I care deeply about. It’s a journal — part personal reflection, part design log.
I’ll be walking through the Software Development Lifecycle (SDLC) step-by-step, using GRIOT as my working example. Each post will focus on how I’m applying a core software engineering principle to a system that’s rooted in voice, memory, and presence.
Here’s what’s coming:
- Intro: Why I’m Rebuilding My Software Mindset (you’re here)
- 1 – Requirements: WRSPM, Emotional Clarity, and Designing GRIOT with Intention
- 2 – Architecture: Mapping GRIOT’s Brain – Modules, Flows, and Responsibility
- 3 – Modularity: Sacred Simplicity – Keeping GRIOT Loosely Coupled, Highly Cohesive
- 4 – Implementation: Building the Heartbeat of GRIOT – From Voice to Reflection
- 5 – Testing: Testing a Soulful System – What Coverage Means When Meaning Matters
- 6 – Dev Models: Waterfall, Spiral, and When to Break the Rules
- 7 – Agile + Scrum: What Agile Taught Me About Reflective Software
- 8 – V1 Recap: From Thought to Soulware – Reflecting on What I’ve Built
- (Bonus) How GRIOT Honors the African Griot Tradition in a Modern AI Agent
Whether you’re a junior dev trying to build with more intention, a senior who still believes in fundamentals, or just someone curious about designing software that feels more human — you’re welcome here.
This is my process, shared in public. Not polished. Not perfect. But real.
Who This Is For
This series is for anyone who’s ever looked at their own codebase — or career — and thought:
“I’ve come far… but I don’t feel grounded.”
“I know how to ship, but I want to design with clarity.”
“I’ve been coding for years, but I’m not sure I ever truly built from the inside out.”
If that’s you — welcome. You’re not behind. You’re just ready to go deeper.
This is for:
- Developers in transition — rebuilding your approach, your confidence, or your sense of purpose.
- Mid-level engineers who want to reconnect with the fundamentals — not to check a box, but to sharpen your edge.
- Students and self-taught devs who want to see how real projects evolve when built with care.
- Builders who care about culture, identity, and reflection — and want to weave those values into what you make.
You don’t have to know everything.
You just have to care about how and why you build — not just what.
That’s who I’m writing for.
And that’s who I’m writing as.
Conclusion
I’m not starting from scratch.
I’m not trying to prove anything.
I’m just choosing to rebuild — with more clarity, care, and rooted presence than before.
GRIOT is my canvas.
The SDLC is my guide.
And this series is my mirror — a space to reflect on how I’m growing, not just what I’m building.
If you’ve ever felt like your process was out of sync with your values…
If you’ve ever wanted to write software that feels aligned with who you are…
Then maybe this series will give you something useful — or at least remind you that you’re not alone.
This is not about getting it perfect.
It’s about reclaiming the craft — one intentional step at a time.
Let’s begin.
