Forem: Adam El Kabir

System Overhaul: How I Hacked My Biology to Become a Developer

Adam El Kabir — Wed, 04 Mar 2026 22:41:04 +0000

Hacking My Biology to Code : My Reconstruction After School Failed Me

1. The School System : A Broken Safety Net

I’ve always been what people call a "good student." For me, the cycle was fluid, almost addictive : understand a concept, apply it, get a grade. It was a machine I excelled in, an environment where I felt safe. Academic success was my compass, promising a bright, pre-defined future.

But as the years went by, biological reality shattered that momentum.

My health is fragile, and my stamina is limited. These are biological parameters I cannot change. In this context, keeping up with the frantic pace imposed by the school system became a trial of strength, a daily battle that grew increasingly exhausting, both physically and mentally.

By burning myself out trying to fit into a mold that ignored my limits, I hit a breaking point. I, the formerly "gifted" student who was always ahead, became a shadow of myself, completely falling behind. It took one more hospitalization-one too many—to face the brutal truth : I was treading water in a void. And at what cost?

2. The Reasoning: The Click

Let’s be real: struggling sucks. But knowing my future was limited to default administrative tasks just because of my disability sucked even more. That’s not me. I need to feel alive : I need to be in the action.

Spending my days behind a screen for a salary barely lower than the social aid I already receive (via the Belgian state) wasn't enough motivation. But I had to look that reality in the face. To move forward, I needed a more powerful engine. I asked myself three fundamental questions:

What does success actually mean to me ?
What is my true goal in this life ?
Which professional field should I aim for ?

Success is a blurry concept, but my conclusion was sharp : I don't want to endure my life : I want to build it. My goal is to possess real craftsmanship and to be truly useful. I want my success to be the mirror of my efforts, filling the silence of a solitary path with the pride of creating value and the financial freedom to finally live life on my own terms.

After deep research, a field I had always been intimidated by emerged : Programming. A vast universe where the only limit isn't the body, but logic.

// Handling a lack of motivation through biological optimization
function handleMentalState(motivation, knowledge) {
  if (!motivation && knowledge) {
    const body = {
      hydration: 0,
      caffeineLevel: 0,
      needsRest: true,
    };

    // We don't wait for motivation; we prepare the environment
    body.hydration += 500;   // A large glass of water
    body.caffeineLevel += 1; // That famous pure black coffee
    body.needsRest = false;  // Metabolic wake-up activated

    // Discipline takes over when motivation is at 0
    const discipline = true;

    return {
      readyToCode: discipline && body.caffeineLevel > 0,
      currentTask: "Active Recall & Practice",
    };
  }
}

I chose programming because it matches my intellectual hunger with a revenue potential that reflects the value of my logic. In a world where code is the invisible 'operating system' of everything, mastering it ensures I’ll never be obsolete. By building the systems that run the world, I’m not just looking for a job—I’m forging a universal key to my own future.

3. First Choice : Biting Off More Than I Could Chew ?

Since I was starting from scratch, I chose to begin with Web Development. It’s a field known for its accessibility and high market demand. To be honest, the visual side—"creating interfaces" never really appealed to me. But since everyone said it was the easiest path to start, I took the challenge.

I wanted to prove to myself that I could master it quickly, almost like a formality... The "me" of the past had no idea what was actually coming. Behind the apparent simplicity of web pages lay a world of logic and problem-solving that would put my pragmatism to the ultimate test.

A visual schema of a design system.
(The kind of thing that used to intimidate the past "me".)

4. The Mirage or the Target ?

Looking at the developer profession from afar, you can easily be blinded by a kind of "modern dream." The numbers circulate, success stories abound, and for someone looking for an exit strategy, the temptation is immense.

The Attraction of Numbers
On paper, the prospects are dizzying. In Belgium and France, market averages draw a trajectory few other sectors can offer without a state diploma:

Salaried: Often starting around €3,500 gross/month for a junior, with the potential to cross the €6,000 mark as a senior.
Freelance: With a Daily Rate (TJM) between €300 and €450 for a beginner, the math is simple.

A brief warning: the junior fullstack developer market is currently tight and more competitive than before. Opportunities do exist, but they are neither automatic nor guaranteed, standing out now requires concrete projects, real autonomy, and strong adaptability.

More Than a Salary: Freedom
Beyond the money, it was the lifestyle that hooked me. I saw the promise of total geographic freedom: the ability to build my own projects (SaaS) and work from the comfort of my home. But most importantly, I realized this job offered a unique versatility : the analytical skills I develop here are powerful levers for any future challenge.

It was a promise of total autonomy, a way to bypass my physical limits by betting everything on my intellect. But to reach this dream, I first had to fix a major issue: the interface between my brain and the machine.

Custom Ergonomics: My Setup, My Rules
Using a standard keyboard was not compatible with my physical condition. Instead of waiting for external solutions, I decided to "hack" my own environment. As a long-time gamer, I’m used to optimizing keybindings to maximize performance. I simply applied that logic to my work.

Here is a brief demo:

Controller workflow - Album on Imgur

Discover the magic of the internet at Imgur, a community powered entertainment destination. Lift your spirits with funny jokes, trending memes, entertaining gifs, inspiring stories, viral videos, and so much more from users like ElAkab.

imgur.com

Using JoyToKey, I mapped my entire keyboard (the key points, at least) and my mouse onto a PS4 controller.
The result ? I can write, scroll, and execute complex shortcuts with total fluidity. I transformed my gaming experience into surgical execution speed for code. 😎🎮

Between the dream shown on social media and the reality of a screen full of errors, there was a gap. Controller in hand, I was finally ready to cross it. But one question remained :

Why do some succeed where so many others quit ?

5. The Plan : Hacking My Own Biology

I understood one thing very quickly : this field is infinitely complex. It requires mastering a multitude of concepts doomed to certain obsolescence, forcing a perpetual learning cycle.

To be honest, the prospect of permanent instability made me uncomfortable, but I chose to face it. I realized that to avoid quitting halfway, simple "willpower" wouldn't cut it, it runs out too fast. I had to conduct a deep investigation, not just into the gears of code, but into my own functioning. My goal became clear :
optimize my cognitive system for a long-term learning marathon.

I. Dopamine Management : Triggering Motivation

To keep motivation constant, don't wait for it > protect it. I discovered my brain was saturated with "cheap dopamine": social media, passive entertainment, and poor-quality food. To fix this, I decided to regulate my sources of pleasure to retrain my brain to enjoy complex effort.

II. Nutrition : Brain Fuel

We often forget the brain is the body’s most energy-hungry organ, consuming about 20% of our daily calories. Apparently, thinking hard burns calories, but it requires high-quality fuel. I realized I was sabotaging my own cognitive abilities through malnutrition and dehydration.

III. Lifestyle : The Infrastructure of Cognition

The image of the nocturnal, sedentary dev is a biological error.

Natural Light & Focus : Exposure to sunlight in the morning regulates serotonin and melatonin. This ensures peak concentration during the day and restorative sleep at night.
Movement : Sedentary habits "put the brain to sleep." Moving releases the BDNF protein, a literal fertilizer for your neurons.
Visual Disconnection : Staring at a screen fatigues eye muscles. Looking into the distance (more than 6 meters) releases tension and activates creative thinking.

IV. The Flow State: High-Performance "Zone"

This is the phase of deep focus where the brain exploits its full potential. For a dev, it’s the Holy Grail of productivity. To activate it, I ensure a balance between challenge and skill, and I eliminate all micro-interruptions (it takes an average of 23 minutes to get back into focus after a break).

We all have a Chronotype, a biological profile that determines our peak alertness. By aligning my schedule with my nature as a "Lion" (😎), I stopped fighting my own biology and started working with it.

6. The Framework : Turning Desire into Discipline

The Deep Work Block (05:00 AM – 12:00 PM)

I start at dawn to enjoy absolute calm.

Metabolic Wake-up : A large glass of water and technical reading.
Theoretical Immersion : 90 minutes after waking, I take my pure black coffee and start intensive online courses. I use Active Recall to ensure the info sticks.
Practical Consolidation : I immediately turn theory into practice with micro-projects.

Side Note : I’ve recently built a tool called EchoFlow. It’s designed to help you manage your notes cleanly and features an interactive quiz mode powered by an LLM to test your knowledge. It’s probably my most complete project to date (though there's always room for growth!), and I’d love to get your feedback while it's still in beta.

The Recovery Block (12:00 PM – 02:00 PM)
Maintenance for my cognitive system : fresh air, Vitamin D, and healthy fuel for the rest of the day.

The Consolidation Block (02:00 PM – 07:00 PM): The Trial by Fire
After the mental reset of my midday break, I transition into building. This is where theory meets reality. I pour my heart into creating tools that aren't just functional, but useful and visually striking—fueling the personal satisfaction that keeps me going.

As I’ve progressed, I’ve started using AI to "scout the terrain" for increasingly ambitious projects. However, I’ve made one rule absolute: no copy-pasting. I refuse "pre-chewed" code. I choose to get my hands dirty, wrestling with every bug and architectural choice to ensure these habits are permanently hardwired into my brain.

The Decompression Block (07:00 PM – 09:00 PM): The Well-Deserved Rest
After a day of intense immersion, it is crucial to signal to the brain that the "effort phase" is over. This is the moment when the "background compilation" of everything I’ve learned begins.

Nutrition & Downtime : I eat a balanced meal, staying consistent with my high-quality fuel logic. Watching a show allows me a moment of total disconnection. This psychological reward is necessary to sustain this pace in the long run.
Pre-sleep Ritual : I limit the number of episodes to protect my rest time. Before bed, I finish with a short, calm reading session. This helps me step away from screens, soothe the nervous system, and prepare for high-quality sleep.

Note : This rhythm works for me because it accounts for my unique history and specific needs. If you find yourself in a similar situation, I encourage you to use the principles I’ve established as a blueprint to build your own framework—one that respects your personal chronotype, your motivation levels, and your overall goals.

Verdict: So... Are we there yet?

After two years of deep immersion, I’ll be honest : I don’t feel fully "ready" yet. Perhaps it’s the infamous Imposter Syndrome creeping in, and if it is, I’ll do what I’ve always done : work on myself until I break through.

Otherwise, I plan to drown that doubt in a flood of new skills and increasingly complex, targeted projects. I don't see this as a weakness, but as methodical preparation. Coding is an endurance sport. If I don’t reach the finish line tomorrow, or next week, one thing remains certain : I will get there.

For those developers curious about what I’ve managed to build over these past two years, feel free to dive into my GitHub. If you have any advice or feedback, I’m all ears—in fact, I’m counting on you to be tough with me 🤥. I’m here to learn, so don't hold back !

What I earned
This journey has transformed me far beyond syntax and lines of code. Today, I stand on foundations that no one can take away :

Digital Architecture: I finally grasp the invisible gears of the web, moving from simple consumption to structural understanding.
Design & Aesthetics: My eye has evolved. I no longer just make code "work" : I bridge the gap between back-end logic and a seamless user interface.
Human-Machine Symbiosis: I’ve learned to think in algorithms and speak the machine's language as if it were my own.
Biological Engineering: I discovered how to discipline my mind, transforming a fragile health condition into a high-precision energy management system.

Conclusion: From Shadow to Architect

Today, I am no longer a shadow of my former self, nor am I that struggling student who blindly trusted a pre-defined path to lead the way.
I have stopped waiting for permission to move forward.

I navigated this transition entirely on my own. It was a silent, solitary battle where the hardest part wasn't the code itself, but maintaining conviction when no one else understood the vision. I had to be my own mentor, my own cheerleader, and my own anchor. Instead of breaking me, the judgment and the pressure taught me to rely on myself even more.

This journey has transformed me into someone I can finally respect, not out of vanity, but because of the quiet confidence that comes from total self-reliance. I now know that while I don't have all the answers, I have mastered the art of finding them. I’ve moved from being a passive observer to someone who understands the modern world’s mechanics and is capable of building something meaningful from nothing but logic.

I am proud of my journey and, above all, of what I am now capable of understanding, solving, and creating. The "gifted" kid isn't back—someone much stronger has taken his place.

Echoflow (🧠 + 📝 + 🤖)

Adam El Kabir — Sun, 08 Feb 2026 15:36:32 +0000

This is a submission for the GitHub Copilot CLI Challenge

Echoflow - Active Recall Powered by AI

Taking notes is good. Being tested on them intelligently is even better.

A Personal Introduction (first post)

Hi ! I'm Adam, a young self-taught student who has spent months deliberately avoiding AI coding tools.

Why ? Because I wanted to "earn" my skills first to understand what I was building without shortcuts, to struggle through bugs, and to truly grasp the fundamentals. I was convinced that using AI would somehow make me... less of a developer.

But then this GitHub community challenge came along, and I thought :
"Maybe I just needed an excuse 😅"

So here we are. Echoflow is my first real project built almost entirely with GitHub Copilot CLI, and honestly ? It's been transformative. Not because it wrote perfect code, but because it let me stay in the flow—thinking, iterating, and building without constantly context-switching.

What is Echoflow?

Echoflow is an AI-powered Active Recall tool designed to solve a problem I face constantly :

I write tons of notes... and i read them.. That's it.

The idea is simple : instead of passively rereading notes, Echoflow uses AI to quiz you on what you've written. It's like having a study buddy who remembers everything you learned and asks you the right questions at the right time.

Core Features

📝 Markdown-powered note-taking (because plain text is so 2010)
🤖 AI-generated questions based on your notes (powered by OpenRouter)
💬 Conversational quizzing - chat with AI to deepen understanding
📊 Progress tracking - AI analyzes your strengths and weaknesses (not perfectly implemented yet)
🎨 Dark mode UI - because your eyes deserve better
🔒 Privacy-first - your notes stay yours (Supabase RLS)

Here's a demo

The app is pretty intuitive.
After authenticating, you'll find some pre-filled categories: :

Inside each category, you'll find some pre-filled dedicated notes (you can access it by clicking on category) :

If you are in a hurry (or feel confortable with yours notes), you can directly quiz yourself by clicking de "Quiz" button. A modal chat will appear with a relevant question about your note :

The app is now more feature-rich than ever ! It includes full CRUD operations for both categories and notes, along with powerful tools like the multi-select mode for targeted LLM quizzing with a contextual feedback loop ensuring the LLM references its previous conclusions to maintain consistency across conversations. I invite you to explore the project yourself, you can find a deep dive into the mechanics and capabilities on the "Learn More" and "Features" pages (available before authentication).

Try It Out (password for demo account : `N7!qA3@Zp#L9mE$R`)

You can try it out here without signing up. Just click "Demo Account" with the provided password and start creating notes and quizzing yourself (using the single or multiple-selection feature).

Why Active Recall?

Active recall is one of the most effective learning techniques backed by cognitive science. Instead of rereading notes (which feels productive but isn't), you actively retrieve information from memory. Echoflow automates this process with AI.

The Process: From Idea to Deployment

The BMade Method

I started with the BMade methodology, which breaks down the development process into three phases :

Brainstorm - Define the problem, target audience, and core features.
Map - Design the architecture, tech stack, and data flow.
Make - Implement the features iteratively, testing and refining as you go.

GitHub Copilot CLI strictly followed this plan—no feature creep, no random refactors. Just the PRD, executed step by step.

The Tech Stack

┌─────────────────────────────────────┐
│      🌐 Data Acquisition (Input)    │
│  ├─ Next.js Web Application         │
│  └─ Markdown/Rich-text Editor       │
└─────────────────────────────────────┘
                  │
                  ▼
┌─────────────────────────────────────┐
│        🔐 Auth & Persistence        │
│  ├─ Supabase (PostgreSQL + Auth)    │
│  ├─ Row Level Security (RLS)        │
│  └─ Vector Storage            │
└─────────────────────────────────────┘
                  │
                  ▼
┌─────────────────────────────────────┐
│       🤖 AI Logic (Echoflow)        │
│  ├─ OpenRouter API Gateway          │
│  ├─ Prompt Engineering (Context)    │
│  └─ Streaming Responses (SSE)       │
└─────────────────────────────────────┘
                  │
                  ▼
┌─────────────────────────────────────┐
│     🎓 Active Recall (Output)       │
│  ├─ Dynamic Quiz Interface          │
│  ├─ Smart Search Tags (JSON)        │
│  └─ Token/Energy Quota Tracking     │ <- I haven't implemented this yet.
└─────────────────────────────────────┘
                  │
                  ▼
┌─────────────────────────────────────┐
│        ☁️ Infrastructure            │
│  ├─ Vercel (Edge Functions)         │
│  └─ Monorepo (Next.js + Scripts)    │
└─────────────────────────────────────┘

It creates me a prd.md file :

And a architecture.md file :

The "Orchestrator" Strategy: Controlling the AI Flow

To ensure Echoflow remained consistent, scalable, and professional, I didn't just "chat" with the AI — I engineered its environment.

I implemented a strict instruction framework via the .github/copilot-instructions.md file. This file acts as the project's source of truth and enforces the following:

Strict Tech Stack Enforcement — Ensures the project follows the chosen stack (Next.js 15 App Router, Tailwind CSS 4.0, and pnpm).
Architectural Integrity — Defaults to Server Components where appropriate and enforces Zod validation for API routes.
The BMade Workflow — Integrates the BMade methodology into the AI prompts to preserve a "think-before-code" approach.
Commit Discipline — Ensures each change is well-documented and traceable.

MCP: Context7 Integration for Real-Time Documentation

I've also set up the Context7 MCP (Model Context Protocol) with the /mcp command. Context7 injects real-time, version-specific documentation into the AI's context whenever I mention a library or framework. This provides several benefits:

Real-time documentation access — the AI can fetch official docs for 60,000+ libraries instantly.
Reduced hallucinations — Context7 supplies the exact API syntax for the target version, avoiding outdated or incorrect guidance.
Version-accurate examples — it returns code examples that match the versions I'm using (e.g., Next.js 14+), preventing deprecated patterns.
Smoother workflow — no manual copy/paste: the AI retrieves the relevant documentation automatically when prompted (for example with use context7).

By defining the rules of the game before the first line of code was written, I turned the AI from a simple assistant into a specialized senior engineer tailored for Echoflow.

SKILL.md: A Living Document of AI Feedback Analysis

I rencently learned about the concept of a SKILL.md file from this insightful thread. The idea is to have a dedicated file where I analyze the AI's feedback on my code, identify patterns in its suggestions, and reflect on how to improve my prompts and code structure.

I've always wanted to try this.. so i installed some relevant skills :

A Humble Disclaimer

I'm a learner. This is my first real full-stack project, and I'm sure there are "creative architectural choices" in here that would make senior devs cringe 😅

Some things I'm still figuring out:

Could my database schema be better normalized ? Maybe.
Could my analysis of AI feedback be more sophisticated ? Definitely.
Are there edge cases I haven't considered ? Absolutely..
Is security airtight ? Probably not enough (but I did implement RLS and follow best practices 🤞).

I probably made some "questionable" decisions in the codebase. But for a first try, I'm pretty proud of the result and the process I went through. The goal was to learn, experiment, and create something useful, not to create a perfect codebase.

If you find bugs or have suggestions, I'm all ears—teaching me is teaching the next generation of devs (but teach me first please).

The Power of "Vibe-Coding"

Here's what I learned: GitHub Copilot CLI enables 100% "vibe-coding" when used correctly.

What does that mean?

Instead of:

Thinking of a feature
Opening an editor
Writing code
Switching to terminal to test
Switching back to fix bugs
Repeat 47 times

I could just :

Think of a feature
Describe it to Copilot CLI
Watch it implement, test, and iterate
Stay in the flow

To be honest, I did fix a few bugs manually. Sometimes, hopping into the code editor often with a quick assist from Copilot Chat was faster than explaining the context to the CLI. While I had to switch contexts a few times, the overall time lost was negligible compared to the massive speed boost the CLI provided.

The "Flow State" Advantage

When you stay in the terminal:

No context switching between IDE and browser
No manual file navigation
No "where was I?" moments
Just pure creation mode

It's like pair programming with someone who never gets tired, never judges your questions, and always has the docs ready (but you still have to understand the docs yourself).

By the Numbers (GitHub Copilot CLI analysis by the `DEVELOPMENT_LOG.md`)

Development Time: ~12 hours (spread over 5 days + 1 last to finalize)
Lines of Code: ~5,000 (TypeScript + SQL)
Copilot CLI Features Used: 30+
Coffee Consumed: ☕☕☕ ... (too many)
Stack Overflow Visits: 2 (down from ~50 per project)
"Aha!" Moments: Countless

What I Built

Feature	Status	Notes
🔐 Authentication (Google OAuth)	✅	Supabase Auth with RLS
📝 Note Management (CRUD)	✅	Markdown support + syntax highlighting
🗂️ Category Organization	✅	Color-coded, filterable
🤖 Single-Note Quizzing	✅	AI asks questions, you answer
🎯 Multi-Note Quizzing	✅	AI quizzes across multiple notes
💬 Conversational AI	✅	Chat-based learning
📊 Progress Tracking	✅	AI analyzes analysis/weaknesses
🎨 Dark Mode UI	✅	Glassmorphism design
🌊 Streaming Responses	✅	Progressive AI rendering
🔒 Demo Account	✅	Try without signing up

Technical Highlights

1. AI Model Rotation System

// For freemium accounts (default) : Automatically tries free models until one succeeds
const FREE_MODELS = [
    "meta-llama/llama-3.2-3b-instruct:free",
    "z-ai/glm-4.5-air:free",
    "stepfun/step-3.5-flash:free",
    "meta-llama/llama-3.3-70b-instruct:free",
    "qwen/qwen-3-235b-a22b:free",
    "mistralai/mistral-small-3.1-24b:free",
    "google/gemma-3-4b-instruct:free",
];

// For premium accounts (even for the "Demo-account")
const PREMIUM_MODELS = [
    "openai/gpt-4o-mini:paid", // generally this one is used
    "mistralai/mistral-7b-instruct:paid",
];

2. Streaming SSE Implementation

// Progressive AI response rendering
const stream = new ReadableStream({
    start(controller) {
        reader.read().then(function push({ done, value }) {
            if (done) return controller.close();
            controller.enqueue(value);
            return reader.read().then(push);
        });
    },
});

3. Row Level Security (RLS)

-- Users can only see their own notes
CREATE POLICY "Users can view own notes"
  ON notes FOR SELECT
  USING (auth.uid() = user_id);

4. JSONB Feedback Storage

// Flexible AI feedback structure example
ai_feedback: {
  analysis: "The user struggles with recall of key concepts, but shows strength in understanding relationships between ideas.",
  weaknesses: "Really stupid at X topic.",
  conclusion: "I need to review X topic more often, maybe with a different approach.",
}

What I Learned

About AI Coding Tools

They don't make you "lazy"—they make you productive
The quality of output depends on the quality of input (prompt engineering matters)
Staying in the terminal is way more efficient than I expected

I've also learned how to prompt correctly ! With the right context, the CLI enables 100% vibe-coding.

For a skilled developer (or an aspiring one), the real limit isn’t how fast you can type but how clearly you can communicate your intent.

Here's an example of a part prompt i used with :

We can't see well in this screen but my method is :

Explain the idea (or issues) precisely
Share the relevant file using the "@" symbol
Add details if needed (like links) Yeah i'm not professional 😅 but that was my "prompt cycle".

But it's important to have a good understanding of the underlying code and architecture. It's not about blindly accepting AI suggestions, but about guiding the AI with clear prompts and making informed decisions based on its output.

About programming in general

This challenge was a deep dive back into the frontend ecosystem. After focusing heavily on Backend architecture during my studies, this project was the perfect opportunity to bridge the gap and sharpen my React skills.

Modern Stack Discovery : It was my first time getting my hands dirty with Next.js 15 and shadcn ui. The speed of iteration and the "developer experience" they provide are truly game-changing for a solo builder.
Infrastructure & Auth: Integrating Supabase felt seamless, though setting up Google OAuth provided a rewarding challenge in managing secure authentication flows.
AI Orchestration: Finally using OpenRouter provided the model flexibility I’ve always wanted. I had to learn Prompt Engineering on the fly—it was fascinating to see how subtle tweaks in instructions could drastically shift the AI's behavior (you can see my logic in api/ai/generate-questions/route.ts). There is something almost artistic about controlling AI output through code, and it made me deeply appreciate the importance of clear, structured communication with LLMs.
I can already see the immense potential for creating highly customized AI interactions in the future.

What's Next?

After a long break, I will continue improving Echoflow based on user feedback, and I plan to add more features based on the best practices to learn faster and more effectively with AI.

Final Thoughts

The ultimate irony : I spent my time learning development, only to build a tool that helps me learn even more 🤔😎..

Made with 💙 (and lots of ☕) by Adam

Powered by GitHub Copilot CLI 😉

https://github.com/ElAkab
https://twitter.com/El_Akab