Forem: Shakiran Nannyombi

A Developer’s Lesson on Feedback

Shakiran Nannyombi — Tue, 21 Apr 2026 06:49:21 +0000

I built my first React Native MVP for a startup pitch.

I was proud of it… until the feedback started coming in.

Instead of handling it, I passed it to a junior teammate.

At the time, I told myself:
“I just don’t like being told what to do.”

But the truth?

I was tired.
I felt unappreciated.
And I was too attached to my work.

Later that day, I stepped away, came back, and realized something:

The problem wasn’t the feedback.
It was my state when I received it.

As developers, we think we’re logical—but feedback hits your ego, your energy, and your identity.

That’s why we react instead of process.

This was a tough lesson for me, especially after realizing it’s a pattern that’s cost me opportunities before.

I wrote a full breakdown on:

Why devs resist feedback
how ego + burnout affect us
and how to actually handle it better

Read it here 👇
the-code-wasn-t-the-problem-my-state-was

Building Secure AI Agents with Auth0 Token Vault

Shakiran Nannyombi — Tue, 14 Apr 2026 01:55:43 +0000

How I stopped storing sensitive tokens in my database and built a security-first AI system

I built a multi-agent AI assistant that needed access to user data like Gmail, Google Calendar, and Notion.

At first, I thought I had it figured out.

I encrypted OAuth tokens myself and stored them in my database.

It worked… but something didn’t feel right.

The problem with “DIY security.”

During the Auth0 “Authorized to Act: Auth0 for AI Agents” hackathon, I took a step back and reviewed my setup.

My system (Londoolink AI) is built with FastAPI + LangGraph and generates personalized daily briefings using multiple agents:

📧 Gmail Agent
📅 Calendar Agent
📝 Notion Agent
📱 Social Agent

To do that, it relies on OAuth tokens.

And that’s where things got risky.

My original approach:

AES-256 encryption for tokens
Tokens stored in my database
Custom refresh handling

It worked… but it wasn’t scalable or truly secure.

What I realized

I was responsible for things I shouldn’t be owning:

🔐 Encryption key management
🔄 Token refresh logic
📊 Audit trails (basically none)
👀 No visibility into token usage
⚠️ No proper control for sensitive actions

In short:

I was rebuilding a security system from scratch… badly.

The switch: Auth0 Token Vault

That’s when I found Auth0 Token Vault.

And it changed everything.

Instead of managing tokens myself:

Auth0 handles token storage securely
Built-in token refresh just works
Full audit logs out of the box
Tokens never touch my database
Easy to enforce secure access patterns

It basically turns token management into a secure API call.

The result

🔒 More secure by design
📈 Easier to scale
🧾 Fully auditable
🤝 Much more user trust

Most importantly:

I stopped worrying about whether I was “doing security right” and started focusing on building features.

About the project

Londoolink AI is a multi-agent assistant that reduces information overload by generating personalized daily briefings from your connected tools.

🙌 Shoutout

Big shoutout to the Auth0 team for building tools that make secure AI development actually practical.

Read the full story

If you want the deeper breakdown, architecture details, and implementation steps, read the full post here:

Shakiran.hashnode.dev

Let’s talk

Have you built AI agents before?

How are you handling auth + token security?

I’d love to hear your approach 👇

My AI Was Smart… But Useless

Shakiran Nannyombi — Tue, 14 Apr 2026 00:42:07 +0000

I built an AI that generates daily briefings from emails, calendars, Notion, and social media.

It worked. It was fast. It was accurate.

But it had one fatal flaw:

It forgot everything.

Every session = reset.
Every user = stranger.

No memory. No context. No continuity.

Then I Fixed It

I discovered Backboard.io after an Auth0 Hackathon on Devpost, and later explored it deeper during MLH Global Hack Week: API Week 2026.

That’s when it clicked:

My AI didn’t need to be smarter. It needed memory.

What Changed Instantly

After adding memory:

My AI remembers user preferences
Conversations actually continue
Outputs feel personal, not generic

It stopped feeling like a chatbot and started feeling like an assistant.

The Real Shift

Most AI apps today are stateless. That’s the problem.

Without Memory	With Memory
You repeat yourself	Your AI learns
Context is lost	Your AI adapts
Personalization is fake	Your AI improves over time

I break down exactly how I built it here:
👉 https://shakiran.hashnode.dev/how-backboard-io-added-memory-to-my-ai-agent

🙌 Shoutout

Huge shoutout to @MLH Global API Hack Week for the sessions and community that made it easier to explore and build with tools like this in real time.

The Invisible Brains: 5 Surprising Realities of the Tiny Operating Systems Running Our World

Shakiran Nannyombi — Wed, 01 Apr 2026 10:48:15 +0000

How tiny operating systems power billions of IoT devices with just kilobytes of memory.

When we think about operating systems, we usually imagine powerful platforms like Microsoft Windows, macOS, or Linux, designed for laptops, servers, and smartphones, with gigabytes of RAM and multi-core processors.

But the majority of computers on Earth don’t run those systems.

Instead, they run tiny operating systems on microscopic hardware: microcontrollers with 10 KB of RAM, a 50 MHz processor, and batteries expected to last years.

These “invisible” operating systems power:

medical implants
industrial sensors
smart home devices
vehicle controllers
environmental monitoring systems

Operating systems like Contiki, TinyOS, and Tock OS redefine what an operating system can be.

Here are five surprising realities about how these systems actually work.

Welcome to Fundamentals Mastery: Learning in Public

Shakiran Nannyombi — Wed, 25 Mar 2026 12:30:36 +0000

Read full blog

Every great engineer eventually discovers the same truth:

Strong fundamentals matter more than anything else.

Frameworks change. Tools evolve. Programming languages rise and fall. But the core concepts of computer science and software engineering remain the foundation that great software is built on.

That realization is what inspired me to start this blog.

Why I Started Fundamentals Mastery

My name is Shakiran Nannyombi, and I’m a software engineer who is deeply passionate about technology, developer communities, and continuous learning.

As I continue growing in software engineering, I’ve realized that truly understanding the fundamentals of computer science is one of the most valuable investments I can make.

Instead of just consuming tutorials or jumping from tool to tool, I want to slow down and master the concepts that power modern software systems.

Let’s learn and grow together.

— Shakiran