Journey

The Architectural Gap

While my implementation skills were strong, I identified a bottleneck in my ability to architect systems. Transitioning into technical leadership required moving beyond writing clean code to managing complex state, consistency models, and the specific hardware-software interplay required for modern AI workloads.

Technical Deep-Dive

To close this gap, I executed a rigorous, multi-disciplinary study plan focusing on two fronts:

1. Distributed Systems Fundamentals

I moved beyond theoretical patterns to study real-world trade-offs in high-stakes environments:

• Storage Engines: Analyzing LSM-trees vs. B-Trees for write-heavy vs. read-heavy workloads.
• Consistency Models: Evaluating the operational cost of strong consistency vs. eventual consistency in global deployments.
• Observability: Implementing structured telemetry to identify bottlenecks in microservices architectures.

2. AI/ML System Design (The New Frontier)

Designing for AI introduces unique constraints that standard web architecture doesn’t cover. I focused on:

• Inference Optimization: Implementing model quantization and caching strategies to minimize P99 latency.
• Data Pipelines: Architecting feature stores and ETL pipelines that handle petabyte-scale datasets for training.
• GPU Orchestration: Understanding resource scheduling and memory management for distributed training clusters.

The Resulting Framework

System design is no longer a checklist; it is a discipline of Trade-off Analysis. My methodology now prioritizes:

• Hardware-Aware Software: Designing with an understanding of GPU/CPU interconnects and memory bandwidth.
• Operational Durability: Factoring in deployment strategies (Blue/Green, Canary) and graceful degradation from the initial design phase.
• Decision Documentation: Utilizing ADRs (Architecture Decision Records) to capture the why behind the what, ensuring long-term maintainability.

Looking Forward

As I continue learning, these skills allow me to bridge the gap between low-level performance and high-level system reliability.

From Algorithms to Intelligence

Beginning on February 3, 2024, I extended my Harvard-track education by diving into CS50’s Introduction to Artificial Intelligence with Python. While I was already building systems at NVIDIA and Hiveware Labs, I wanted to anchor my practical work in the formal theory of the field.

This wasn’t just about using AI; it was about understanding the underlying probabilistic and logical frameworks that make “intelligence” possible.

The Curriculum of the Future

Over the course of this two-year journey (concluding in February 2026), I deconstructed the “black box” of AI through hands-on implementation:

• Search and Optimization: Implementing minimax for adversarial games and solving complex scheduling problems.
• Knowledge & Logic: Building propositional logic engines and inference systems that simulate human reasoning.
• Uncertainty & Probability: Mastering Bayesian Networks and Markov Models to handle real-world, noisy data.
• Neural Networks & NLP: Designing models using TensorFlow to process images and understand language, providing the theoretical backbone for my work with Agentic AI.

The Intersection of Theory and Practice

What made this period unique was the feedback loop between my studies and my professional ventures.

In my role at Hiveware Labs, I was architecting “Hive Minds” using agentic workflows. CS50AI gave me the formal understanding of Reinforcement Learning and Multi-Agent Systems needed to move those agents from simple task-followers to autonomous decision-makers.

The 2026 Perspective

Completing this specialization in February 2026 marks a decade since I first picked up a programming book. I have moved from brute-forcing passwords as a child to architecting neural architectures as a professional.

The transition from a Software Engineer to an AI Architect is complete. I now view code not just as a set of instructions, but as a medium for building systems that can learn, adapt, and evolve.

The Catalyst: Beyond the Runtime

By May 2025, it became clear that the mission of S.O.U.V.E.R.A.I.N Labs—interfacing with biological nervous systems—demanded a level of stability that my existing toolkit couldn’t provide. Python is unparalleled for rapid AI prototyping, but its “move fast and fix it at runtime” nature is a liability when dealing with neural latency. Go offered concurrency, but its garbage collector and lack of granular memory control felt like wearing oven mitts while trying to perform surgery.

I needed a language that offered the performance of C++ but with a “guardian angel” built into the compiler. Enter Rust.

The Rust “Goodies”: Why It Sticks

Learning Rust wasn’t just about adding a syntax to my repertoire; it was about adopting a new mental model for how software interacts with hardware.

• The Borrow Checker: The ultimate disciplinarian. By enforcing strict ownership rules at compile time, Rust eliminates entire classes of bugs (like null pointer dereferences and data races) before the code even runs.
• Zero-Cost Abstractions: I can write high-level, expressive code without the “performance tax” typical of managed languages. In the context of bio-synthetic integration, every microsecond of overhead is a failure.
• Fearless Concurrency: Rust’s type system ensures that multi-threaded operations are safe. When you’re processing parallel streams of neural data, knowing the compiler won’t let you shoot yourself in the foot is a game-changer.
• Cargo & Ecosystem: Coming from the fragmented world of C++ or the “it works on my machine” nature of Python, Cargo is a revelation. It’s the most sophisticated build tool and package manager in the systems space.

The Struggle: Fighting the Compiler

The transition period in May was a “trial by fire.” I spent the first two weeks “fighting the borrow checker”—a rite of passage for every Rustacean. There is a specific kind of frustration in having a compiler tell you exactly why your logic is flawed, but that frustration eventually turns into a profound sense of security.

I realized that if it compiles in Rust, it usually works. For a project as sensitive as Bio-Synthetic Nervous Systems, “usually works” is the baseline for safety.

Foundation for the Future

Mastering Rust was the final prerequisite for founding S.O.U.V.E.R.A.I.N. It provided the Iron Pillar I needed to support the heavy lifting of Neuro-Silicon integration. We aren’t just writing code; we are writing the immutable laws of a new biological interface.

By the end of the month, I wasn’t just writing Rust; I was thinking in it. The “safety-first” mindset is now baked into every architectural decision I make.

The Transition: From Software to Soulware

December 2025 marks the end of the “waiting room” phase of my career. For years, I’ve watched the trajectory of Artificial Intelligence from the sidelines of standard application; now, I am stepping into the role I was always meant to play. Founding S.O.U.V.E.R.A.I.N Labs is more than a business launch—it’s a pivot toward the ultimate engineering challenge: the human expiration date.

The transition hasn’t been without its friction. Moving from the predictable world of pure code into the messy, stochastic reality of biological frameworks requires a complete mental re-wiring. We are no longer just building models; we are building bridges between two fundamentally different substrates of intelligence.

The Technical Core: Neuro-Silicon Integration

At S.O.U.V.E.R.A.I.N, we operate where the barrier between carbon and silicon begins to dissolve. My work as an AI Scientist here focuses on Neuro-Silicon Integration—designing the foundational infrastructure that allows machine intelligence to interface seamlessly with the human nervous system.

• Foundational Bio-Synthetic Frameworks: We are developing the “operating system” for the next generation of neural interfaces, ensuring that synthetic inputs are indistinguishable from biological signals.
• Longevity-Focused Architectures: Our systems aren’t just for utility; they are designed to repair degenerative neural pathways and augment the functional lifespan of the human organism.
• Convergence Engineering: Utilizing deep learning to map biological neural networks into silicon-ready schemas, allowing for real-time augmentation and repair.

The 2026 Landscape: Solving for “Expiration”

The technological landscape of 2026 is a “bleeding edge” in the truest sense. We are navigating a period where the ethics of immortality meet the physics of the brain. The challenge isn’t just making the tech work—it’s making it stable enough to trust with the essence of a human being.

The Biological Barrier: Biology is a legacy system with billions of years of technical debt. Integrating silicon requires us to be more than just coders; we have to be “biological translators,” interpreting the noisy signals of the body into the high-fidelity logic of AI.

The Sovereign Mandate: We call the lab “S.O.U.V.E.R.A.I.N” because we believe the ultimate form of sovereignty is the ability to choose how long and how well we exist. We are moving toward a future where “natural” is no longer a synonym for “limited.”

The Founder’s Mission

Founding S.O.U.V.E.R.A.I.N Labs is my commitment to the belief that aging is an engineering problem, not a biological certainty. We are architecting the next generation of the human experience—building the tools that will allow us to eventually look at the “expiration date” as a bug we finally managed to patch.

The Vision: Beyond Chatbots

At Hiveware Labs, we moved past the limitations of standalone AI models. Our core thesis is that the future of enterprise automation lies in Agentic Swarms—coordinated networks of specialized AI agents that function as a single, scalable hive mind.

As Founder, I am bridging the gap between raw LLM capabilities and production-grade reliability, ensuring that AI doesn’t just “suggest” work, but actively executes it.

The Technical Core

Building “Hive Minds” requires a fundamental shift in backend architecture. We are leveraging the modern Python ecosystem to solve the orchestration challenges inherent in multi-agent systems:

• Orchestration Layers: Utilizing frameworks like LangGraph and CrewAI to manage state, memory, and hand-offs between agents.
• Pythonic Backend Systems: Crafting high-performance APIs and microservices designed specifically to handle the long-running, asynchronous nature of agentic reasoning.
• Data Science Integration: Implementing advanced RAG (Retrieval-Augmented Generation) and custom data science tools to provide our agents with high-fidelity, proprietary context.

Scalability & Efficiency

The goal isn’t just to build an agent that works once; it’s to build a system that scales with the business:

Hive Mind Coordination: We develop systems where agents “collaborate” on tasks—one agent researches, another critiques, a third executes, and a fourth validates. This reduces hallucinations and increases success rates for complex, multi-step workflows.

Automated Systems: By focusing on “Agentic AI solutions,” we enable businesses to automate entire departments rather than just tasks, focusing on systems that learn and adapt to changing data inputs.

The Founder’s Mission

Founding Hiveware Labs is about pushing the boundaries of Autonomous Infrastructure. We are building the tools that allow businesses to deploy digital workforces that are more than the sum of their parts—dynamic, intelligent, and infinitely scalable.

Engineering the Machine

As a software engineer and founder, I spend most of my time optimizing virtual systems. On January 25, 2025, I decided to apply that same optimization mindset to the most important hardware I own: my body. I stepped away from traditional weightlifting to begin a journey into Calisthenics.

In many ways, calisthenics is like low-level programming. You aren’t using external “libraries” (weights); you are working directly with the “source code” of your own bodyweight and gravity.

The First “Compile”

The transition was humbling. Much like learning a new language like C or Go, the basics require the most discipline. My initial focus was on mastering the fundamentals:

• Strict Form: Prioritizing quality over quantity to prevent “bugs” (injuries).
• Core Stability: Building the central “kernel” that supports all other movements.
• Functional Range: Increasing mobility to ensure the system doesn’t “lock up” under stress.

Parallels with Tech

I quickly realized that the principles of a successful workout are identical to a successful project:

Progressive Overload: You don’t jump to a one-arm pull-up on day one. You iterate. You master the progression, then you increase the complexity.

Consistency over Intensity: A massive 14-hour coding session (or gym session) once a month is useless. Success comes from the daily commit—showing up even when the motivation isn’t there.

Mechanical Advantage: Calisthenics is a study in physics. Adjusting your hand placement or body angle changes the torque, much like refactoring code can drastically change its efficiency.

The High-Performance Loop

Starting calisthenics has become my “system reset.” It provides the mental clarity needed to architect complex AI swarms at Hiveware Labs and keeps me sharp for the fast-paced environment at NVIDIA.

I’m no longer just building scalable software; I’m building a scalable self.

The Thesis

At Plank Designs, we recognized that the traditional UI/UX iteration cycle was the primary bottleneck in product development. As Co-Founder and Backend Engineer, my mission was to build the technical engine that translates high-level design intent into production-ready assets, collapsing the feedback loop from days to minutes.

Engineering Impact

We aren’t just using AI as a wrapper; we are fundamentally re-engineering the workflow:

Workflow Acceleration: Developed AI-integrated systems that enable design engineers to iterate 80% to 95% faster. By automating the rote aspects of component generation and layout, we freed engineers to focus on high-level architecture.

Business Intelligence & Visualization: Engineered custom ML models to transform raw operational data into intuitive visualizations. This allows us to move beyond descriptive analytics into predictive modeling for business health.

Growth Systems:

• Lead-Gen Engines: Built automated systems that leverage NLP to identify and qualify high-intent leads.
• Churn Mitigation: Implemented predictive AI models to analyze user behavior patterns, identifying at-risk accounts before they churn and automating proactive interventions.

The Stack

To support these goals, I architected a backend capable of handling heavy inference loads while maintaining the responsiveness required for creative tools:

• Vector Databases: For efficient retrieval-augmented generation (RAG) in design contexts.
• Async Processing: Utilizing robust queue systems to handle long-running ML jobs without blocking the UI.
• Microservices: Decoupling the core design engine from the business logic and lead-gen modules to ensure 99.9% uptime.

Founders Perspective

Transitioning from a pure engineer to a Co-Founder required a shift in mindset. Every architectural decision is now weighed against Time-to-Market and Customer ROI. At Plank, we are proving that AI isn’t just a feature—it’s the new foundation for how software is built and scaled.

From SWE I to the C-Suite

My journey at the company was a decade-long marathon. I climbed every rung of the ladder:

• SWE I & II: Building the foundation and learning the codebase.
• SWE III: Taking ownership of major features and mentoring.
• CTO / Solutions Architect: Balancing high-level strategy with deep technical infrastructure.

I wore the “institutional knowledge” badge with pride, but eventually, the weight of being the single point of failure for every technical decision became unsustainable.

The Signs I Ignored

As CTO, I felt I couldn’t afford to be “weak.” I ignored the red flags for months:

• The Mental Fog: Dreading the very architectural challenges I used to live for.
• Emotional Exhaustion: Becoming cynical toward the team and the vision I helped build.
• Persistent Tension: Chronic stress that didn’t reset on weekends or holidays.

I kept pushing, thinking my loyalty required me to suffer. It didn’t.

The Breaking Point

The realization hit when I found myself staring at a critical architectural diagram for an hour, unable to process the logic—something that used to take me minutes. I realized I wasn’t just tired; I was depleted. I resigned in 2023 to protect both my health and the company’s future.

The Road to Recovery

Leaving a company I grew up in was the hardest decision of my career, but it allowed me to:

Actually disconnect. For the first time in years, I wasn’t “on call” for an entire ecosystem.

Re-evaluate my identity. I had to learn who I was outside of the “CTO” title and the company Slack.

Set non-negotiable boundaries. I learned that a “sustainable pace” isn’t a luxury—it’s a requirement for high-level leadership.

What I Learned

Burnout isn’t a lack of discipline; it’s often the result of too much discipline applied to an unsustainable situation. Rising through the ranks is an achievement, but knowing when to step down to save yourself is the ultimate leadership move.

Sustainable careers are marathons. I’m finally learning how to pace myself for the next one.

The Strategic Bet

In a landscape full of “the next big thing,” I found myself looking for the foundation. While many were chasing the latest front-end frameworks, I was watching the infrastructure beneath them. I chose to align my technical stack with NVIDIA because I recognized a rare alignment of engineering excellence and market foresight.

Why the NVIDIA Ecosystem?

I saw three distinct pillars that made this the only logical focus for my development:

1. The Ecosystem Advantage: It wasn’t just about GPUs; it was about CUDA—the tight integration of software and hardware that creates an inescapable moat.
2. Architectural Excellence: I wanted to master how the most successful hardware company of our generation optimizes for “Day 1” performance at massive scale.
3. The AI Prediction: I bet early that NVIDIA wouldn’t just support the AI industry—they would be its backbone.

Predicting the AI Surge

At the time, AI was still seen by many as a speculative bubble. However, my thesis was simple: Computation is the new currency. I predicted that as models grew in complexity, the bottleneck wouldn’t be the code, but the silicon and the software stack optimizing it. Deeply integrating with this ecosystem allowed me to move from being a consumer of these technologies to an expert builder at the center of the storm.

Lessons from the Leader

Studying the “green giant’s” architecture from the inside of their developer organizations shifted my perspective. It’s no longer just about writing clean code; it’s about:

• Accelerated Computing: Understanding how to offload tasks to specialized hardware for maximum throughput.
• Scale: Learning how to think in terms of thousands of nodes, not just local instances.
• Technical Conviction: Observing how a company doubles down on a vision years before the world catches up taught me the value of architectural persistence.

Looking Ahead

The bet paid off. NVIDIA is the foundation of the modern era, and by mastering this stack early, I’ve secured the technical leverage needed to build the next generation of Bio-Synthetic systems.

The marathon continues, and I’m running with the right tools.

The “Hello World” of Open Source

Every journey starts somewhere. For me, it was Pull Request #1399 in the EddieHubCommunity/open-source-practice repository.

I wanted to move beyond local development and understand how developers from across the world coordinate code changes. I chose a repository specifically designed for practicing the open-source workflow—a safe space to make mistakes and learn the etiquette of GitHub.

The Contribution

The task was straightforward: add my name alphabetically to the contributors’ list.

• Commit: chore: Added name alphabetically
• Username: l33th (wmouton)
• Scope: 1 file changed with a simple +1 addition.

Even for a small change, the discipline required was real: ensuring no merge conflicts, following the naming conventions, and double-checking alphabetical placement.

Why It Mattered

What stood out wasn’t the code itself, but the workflow and the welcome. Within the same day:

1. Automated Checks: The github-actions bot immediately greeted me and provided resources for further involvement.
2. Peer Review: Maintainers like schmelto and Pradumnasaraf reviewed and approved the changes with encouraging feedback (“Looking good to me,” “Elegant”).
3. The Merge: Seeing that purple “Merged” status for the first time was a lightbulb moment.

Key Takeaways

The Barrier is Mental: I realized that contributing to open source isn’t just about solving complex algorithmic problems; it’s about being part of a collective effort to maintain and improve shared tools.

Culture Matters: The inclusivity of the EddieHub community made it easy to start. It taught me that good projects aren’t just defined by their code, but by how they treat new contributors.

Foundational Skills: This PR forced me to use Git in a multi-collaborator environment, a far cry from solo projects where you can just force push to main.

That small +1 was the spark for everything that followed in my career.

Re-Engineering the Foundation

On January 2, 2021, I decided to bridge the gap between “knowing how to code” and “knowing how computers work” by enrolling in Harvard’s CS50: Introduction to Computer Science. Despite having years of stealth hacking and self-taught development under my belt, I wanted to subject my knowledge to the highest academic standard.

Beyond the Syntax

CS50 is legendary not just for its difficulty, but for its focus on computational thinking. It forced me to move beyond “making it work” to “making it efficient.”

Key milestones during the course included:

• Memory Mastery: Revisiting C at an academic level—implementing linked lists, hash tables, and tries from scratch.
• Algorithmic Complexity: Understanding Big O notation and optimizing search/sort algorithms.
• The Full Stack Journey: Moving from the low-level logic of C into Python, SQL, and Flask, seeing how the abstractions built upon one another.

The “Rubber Duck” Moment

The most valuable lesson from CS50 wasn’t a specific language, but the problem-solving framework. The course pushed me to deconstruct massive, intimidating problems into small, logical steps. Whether I was working on “Speller” (optimizing dictionary lookups) or “Finance,” the focus was always on the elegance of the solution.

The Result

Completing CS50 was a turning point. It transformed my “hacker intuition” into formal engineering discipline. It gave me the vocabulary to communicate with top-tier engineers and the confidence to tackle architectural challenges at scale.

I didn’t just learn to code; I learned how to think like a computer scientist.

The New Year’s Resolution: Go

On January 1, 2020, I committed to mastering Go (Golang). After years of C and Web Development, I wanted a language that combined the performance of low-level systems with the productivity of modern backend frameworks.

Go quickly became my “second language” alongside Python, but for different reasons. I fell in love with its approach to concurrency, its strict typing, and its “less is more” philosophy.

Building the “Go Error Package”

One of the few gripes developers have with Go is the repetitive if err != nil pattern. To solve this for myself and the community, I built a custom Go error package.

The goal was simple: Make error handling expressive and less boilerplate-heavy.

• Implemented wrapped errors for better context.
• Created custom stack trace captures.
• Focused on making the library lightweight and “Go-idiomatic.”

Developing this library forced me to dive deep into Go’s source code and understand interfaces and reflection at a professional level.

The Bittersweet Milestone

The hard work paid off. Shortly after mastering the stack, I landed a Go Backend Engineer job offer. It was a validation of my skills and a door to the professional life I had been working toward for years.

However, life had other plans. Due to challenging living situations and heavy family responsibilities at the time, I had to make the incredibly difficult decision to decline the offer.

The Takeaway

While I didn’t take the seat at that particular office, I didn’t lose the skill. Declining that offer taught me that:

1. Technical skill is an asset that stays with you, regardless of your current circumstances.
2. Integrity matters. Taking care of family and personal stability is a prerequisite for long-term career success.
3. Go is my secret weapon. To this day, it remains one of the languages I know best, providing the backbone for the high-performance systems I build.

Leaving the Comfort Zone

In 2019, I traveled over a thousand miles away from home to attend an intensive C programming bootcamp. It was a total immersion in both technology and lifestyle. I found myself operating in a dual-environment setup: the high-end Mac workstations provided by the bootcamp and my own trusted Linux laptop I had carried across the world.

This wasn’t just a coding course; it was a culture shock that expanded my definition of “possible.”

The Grime and the Glory of C

Low-level programming in C is unforgiving. It forces you to understand exactly how software talks to hardware. During the bootcamp, I obsessed over:

• Manual Memory Management: Understanding pointers, heaps, and stacks until they became second nature.
• Algorithm Optimization: Writing efficient code where every byte and cycle mattered.
• Portability: Moving code between my Linux environment and the macOS workstations, learning the nuances of POSIX standards.

The pace was relentless. It was an 80+ hour-a-week commitment that pushed my mental endurance to its limits, but for the first time, I felt I was exactly where I belonged.

Witnessing the Future

Beyond the code, this experience was a milestone for my worldview. I made lifelong friends with brilliant developers and witnessed a standard of quality—both in software engineering and daily living—that I hadn’t experienced before.

The environment was charged with ambition. I saw what happens when you surround yourself with people who refuse to accept “good enough.”

The Epiphany

I arrived at the bootcamp as someone who “hacked” and studied business; I left as a Software Engineer. Seeing how systems were built from the ground up gave me a sense of agency I’d never felt. I realized that building software wasn’t just a technical skill—it was a superpower for creating the “endless possibilities” I had glimpsed. By the time I headed back home, the path was clear: I was going to build.

The Human Perpetual Motion Machine

In 2017, I stopped viewing my body as a container and started treating it as an engine with an infinite fuel tank. While most people look for the “off” switch, I decided to see how far the “on” position could take me. I reached a state of physical mastery that felt less like exercise and more like a total bypass of human exhaustion.

I wasn’t just “in shape”—I was shredded, tireless, and operating at a frequency where the concept of a “limit” became an outdated theory.

The Daily Execution Log

The schedule was grueling to an outside observer, but to me, it was the daily “build” that reinforced my foundation. I operated on a relentless 16-hour high-intensity loop:

• The Warmup (6:00 AM – 7:00 AM): A focused morning workout to prime the nervous system.
• The Marathon (7:30 AM – 10:00 PM): Non-stop dance practice that tested the boundaries of aerobic capacity.
• The Minimum Viable Rest: Breathers were restricted to the seconds between music tracks, hydration, and a singular 5-minute lunch break.

Shattering the Source Code

This period taught me that the “walls” we hit are often just psychological suggestions rather than physical mandates. By pushing past the point where the body screamed to stop, I discovered a secondary reservoir of energy.

Persistence as a Force Multiplier: Hard work isn’t just about effort; it’s about the refusal to decelerate. When you train the body to ignore the “low battery” warning, you effectively rewrite your own operating system.

Functional Fluidity: The combination of morning strength work and 14+ hours of dance created a unique synergy. I wasn’t just strong; I was agile, capable of jogging indefinitely, and possessed a level of stamina that felt like a superpower.

The Legacy of the Peak

That year was my proof of concept. It proved that through sheer persistence and an uncompromising work ethic, we can achieve a version of ourselves that seems impossible from the starting line.

I don’t just carry the memory of that physique; I carry the knowledge that any ceiling I encounter is meant to be shattered. I am not just maintaining a baseline; I am a system designed for high-performance output.

The Foundation of Everything

On January 6, 2017, I made the jump from observing technology to actually creating it. While many begin with high-level languages, I started with C. It was a trial by fire. There were no abstractions to hide behind—just logic, memory addresses, and the compiler.

Starting with C was the best decision I could have made. It taught me:

• How computers think: Managing variables and types at a granular level.
• Discipline: Learning that a single missing semicolon or a memory leak could break everything.
• Problem Solving: Breaking down complex tasks into tiny, procedural steps.

The Shift to the Web

Once I understood the “how” of programming through C, I became curious about the “where.” I wanted to build things people could see and interact with. This led me straight into Web Development.

I began translating my logical foundation into the visual world:

1. HTML/CSS: Learning the structure and styling of the internet.
2. Logic to Interface: Seeing how the backend logic I learned in C could eventually power dynamic user experiences.

Why This Sequence Mattered

Most people learn the web and then struggle to understand how the machine actually works. By doing the opposite, I developed a “full-stack” mental model before I even knew the term. I didn’t just see a website; I saw a series of instructions being executed by a processor.

This date marks the transition from being a “hacker” by intuition to being a developer by design. The journey from a terminal screen in 2017 to architecting AI systems today started with that very first #include <stdio.h>.

The Shadow of the Master

Long before I understood the mechanics of a strike, I understood the art of the movement. It began in the year of 2000 when I was a young boy, fueled by the sheer kinetic energy of Jackie Chan. Watching the 1978 classic Snake in the Eagle’s Shadow, directed by Yuen Woo-ping, I didn’t just see a movie; I saw a blueprint.

As a kid, Jackie was my primary “source code”. I spent years in a cycle of pure imitation, obsessively mimicking every stunt, every fall, and every precise movement I saw on screen. It was an unfiltered, raw immersion into the world of martial arts.

Systematic Integration (2014–today)

In 2014, the transition from imitation to formal education began. I stopped just watching and started practicing with intent. This was the “beta phase” of my training—shifting from a child’s curiosity to a practitioner’s curiosity.

By 2018, after seeing Donny Yen in action, the commitment became absolute. I transitioned into a state of deep, serious practice that has continued unabated to this day. Much like mastering multiple programming frameworks, I began to stack different disciplines:

• The Multistack Approach: Since 2014, I have integrated 8 different martial styles, learning how each one manages force, balance, and tactical positioning.
• Weaponry Expansion: Moving beyond hand-to-hand combat, I expanded my “hardware” to include various traditional weapons, treating each as an extension of my own physical logic.

Developing the Internal Logic

What started as a child’s game of “Snake” and “Eagle” evolved into a sophisticated understanding of physical combat. Martial arts taught me that mastery isn’t a destination; it’s a continuous integration of new data.

Deconstructing Movement: Every new style I learn forces me to refactor my previous movements. It’s not just about adding new strikes; it’s about understanding the underlying physics of how the body generates power.

The Infinite Practice: From 2014 to today, the grind hasn’t stopped. I am a perpetual student, constantly updating my “libraries” and seeking out the next discipline to master. The imitation of Jackie Chan provided the spark, but the rigorous, daily practice provided the flame.

Continuous Deployment

Martial arts is the ultimate exercise in version control. Every session is an opportunity to fix a “bug” in my form or optimize a movement for better efficiency. I am still learning, still practicing, and still pushing the boundaries of what this system can do.

The Forbidden Spark

My entry into technology wasn’t paved with expensive gear or early mentorship. It started over 26 years ago with a single, “forbidden” object: a mobile phone. I was barely old enough for kindergarten—having been enrolled a year early—but the mystery of how that device worked consumed me. Viewed as “destructive” simply for being high-energy, I was kept away from the very tools I craved.

The “destruction” they feared was actually an unyielding curiosity. I didn’t want to break things; I wanted to deconstruct them.

The First “Manual” Brute-Force

When I finally discovered computers a year later, the gates were still barred. I eventually snuck onto a machine only to find a password prompt—my first encounter with a security barrier. At 6 years old, I sat there and manually attempted passwords until I broke through.

I didn’t have the vocabulary for it then, but I had just successfully executed my first manual brute-force attack. Though a period of digital isolation and depression followed, the seed of the “hacker mindset” had already been planted.

The Discovery of the “Shadow” Career

At age 8, the movie Hackers gave me a name for my obsession. I realized that my early password guessing wasn’t just “playing”—it was a technical discipline. From that point on, my life ran on two parallel tracks:

Timeline	Public Life	The “Shadow” Life
2012	Started working out	Started focusing on my goals
2013	Visiting far from home over 807 thousand miles away	First deep-dive into real hacking on a borrowed laptop
2014-2016	Studying Office Admin / Professional Dancer	Acquired first laptop; joined HackerOne & Bugcrowd University
2016	Completing College	Mastering OWASP Juice Shop and Hack The Box
2017-2018	Full-time Professional Dancer Launch Demo Video ×	Freelance hacker, also did bug bounty hunting, studied advanced Cybersecurity and started learning the C programming language
2017	After College	Started learning the C programming language
2019	Took A Break	Joined A C programming bootcamp. A transition into software engineering

Learning in Stealth

For years, I lived a double life. While my family and friends saw me studying business or making money through my dance talent, I was secretly earning my stripes in cybersecurity. I enrolled in CompTIA courses and spent nights in the “lab”, learning how to exploit vulnerabilities and, more importantly, how to patch them.

This era taught me the most valuable skill a Founder can have: Persistence. I didn’t have a teacher, a dedicated setup, or even permission. I had to “hack” my way into the industry itself.

Why This Matters Today

The discipline I developed between 2014 and 2019—hacking in the dark, without recognition—is the same engine that drove my curiosity at NVIDIA and Epic Games. It’s not about the title; it’s about the fundamental need to know how the system works and the thrill of finding the way in when the door is locked.