Sign in Subscribe
home

Welcome to 8 Protocols

I’m Alvis Ng, a technical lead based in Malaysia.

I write about the systems that shape how we build—from software architecture and AI to product strategy, team culture, and the human mind behind the code.

At 8 Protocols, I share principles, stories, and experiments that keep work sharp and human. Sometimes that means untangling a stubborn frontend structure. Sometimes it’s questioning a “best practice” that everyone treats as gospel. Sometimes it’s about faith, psychology, and the quiet forces that shape why we work the way we do.

I write to keep asking better questions: about craft, about meaning, and about how we balance precision with purpose.

I share these notes and stories at least three times a month. Long enough to stay with you. Short enough for a cup of coffee.

Featured stories · Code, culture, clarity

Prompt Engineering and the Illusion of Instruction

Prompt Engineering and the Illusion of Instruction

We think we’re giving orders. We’re steering a next-token engine. Prompts work when they mirror patterns the model has seen. Tiny phrasing changes flip outcomes. Guide with short roles, small examples, and simple formats. Verify. Cooperation, not command.
What Makes a Senior Developer Senior?

What Makes a Senior Developer Senior?

Seniority isn’t a title. It’s how you work when it counts: choose the boring tool when it wins, ship with guardrails, teach without theater, cut complexity, and own outcomes after merge. Tradeoffs over tricks. Clarity over clever. Spotlight traded for team lift.
Sorting Words, Clustering Thoughts

Sorting Words, Clustering Thoughts

We sort words without thinking. Machines can't. They learn to draw boundaries and find themes: spam or not, tickets by topic. Use labels when you need decisions and clusters when you need discovery. Start there. Patterns come first, meaning follows.
Inside the Clockwork of an AI’s Mind

Inside the Clockwork of an AI’s Mind

Ask a question, get a fluent answer. Under the hood, no insight, just a fast loop picking the next token, guided by attention and a tiny memory. See the gears, not a ghost. When you learn the strings, you know when to trust it and when to steer.
Chopping Language, Weaving Meaning

Chopping Language, Weaving Meaning

Language models don’t read like we do. They slice text into tokens and map them to vectors. Meaning becomes pattern, not understanding. Learn the quirks of tokenization and embeddings to write tighter prompts, spot bias, and know what gets lost.
The Erosion of Virtue

The Erosion of Virtue

Speed is prized; thoughtfulness gets labeled “overthinking.” But 深思熟虑, think deeply and act with care, is not delay. It is judgment. Pause for choices that matter. Ask who benefits from the rush. Measure twice, cut once. Finish better, regret less.
From Bag-of-Words to GPT

From Bag-of-Words to GPT

We moved from counting words to modeling meaning. LLMs write, code, and summarize, but they also hallucinate and echo bias. Use them as partners, not oracles. Keep your hand on the wheel. In a world where language is cheap, make your thinking rare.
The Algorithmic Throne and the Cacophony of Democracy

The Algorithmic Throne and the Cacophony of Democracy

How our faith in perfect algorithms threatens real self-correction, and why democracy survives by making room for noise.

Latest

Jan 05
Beyond the Spotlight. Finding Strength When You’re Not the Favorite

Beyond the Spotlight. Finding Strength When You’re Not the Favorite

You’ve felt overlooked even when you worked hard. As an introvert, praise often went to extroverted peers while your work stayed quiet. That sting is valid. But not being the favorite can also become your edge—the space to reflect, grow quietly, and discover your own strengths.
7 min read
Jan 05
A Year with Next.js Server Actions: Lessons Learned

A Year with Next.js Server Actions: Lessons Learned

Server Actions in Next.js let you write server-side code directly in React components, cutting down boilerplate and simplifying client-server communication. They shine for data mutations and UI-tied operations, but require care to avoid tight coupling, overuse, or vendor lock-in.
11 min read
Jan 04
Slow Down to Move Faster

Slow Down to Move Faster

In software development, speed can be costly. Quick fixes often hide deeper issues, leading to more rework. Slowing down to think deliberately, plan, and explore options may feel slower at first but often produces better solutions, fewer bugs, and stronger long-term results.
4 min read
Jan 03
Are We Sleepwalking Through a Digital Deluge?

Are We Sleepwalking Through a Digital Deluge?

Our attention is being mined. From autoplay videos to endless scroll, every platform is built to keep us hooked. This constant stimulation rewires our brains, eroding focus. The same plasticity that harms can heal if we set boundaries, slow down, and choose deliberate engagement.
4 min read
Sep 11
Managing complexity: Shared business logic in Next.js (Part 1: Server-Side Architecture)

Managing complexity: Shared business logic in Next.js (Part 1: Server-Side Architecture)

In Next.js 14+, structuring shared business logic through repositories, action functions, and standardized error handling cuts duplication and keeps API routes and Server Actions consistent. This layered approach boosts maintainability, type safety, and sleep quality.
9 min read
Mar 05
Advanced Union Type Techniques in TypeScript — 05 Object Values with const Assertion

Advanced Union Type Techniques in TypeScript — 05 Object Values with const Assertion

Const assertions in TypeScript lock values to their exact literal types and make them readonly, preventing accidental changes. Used strategically in configs, mappings, and critical state, they catch errors early, keep code predictable, and boost maintainability without unnecessary rigidity.
6 min read
Jan 15
Advanced Union Type Techniques in TypeScript — 04 Extracting Types from Discriminated Unions

Advanced Union Type Techniques in TypeScript — 04 Extracting Types from Discriminated Unions

Discriminated unions use a shared property to let TypeScript narrow types automatically. From sorting messages to handling server errors, they boost clarity, IntelliSense, and safety, ensuring each variant is processed with the right properties and avoiding runtime surprises.
6 min read
Jan 12
Advanced Union Type Techniques in TypeScript — 03 Indexed Types

Advanced Union Type Techniques in TypeScript — 03 Indexed Types

Indexed access types let you pull property types directly from other types, combining JavaScript’s flexibility with TypeScript’s safety. From dynamic getters to deep extractions in nested objects, they keep complex structures consistent, reliable, and easier to maintain.
4 min read
Jan 09
Advanced Union Type Techniques in TypeScript — 02 Excluding Types

Advanced Union Type Techniques in TypeScript — 02 Excluding Types

The Exclude utility type in TypeScript filters out unwanted members from a union, leaving only the relevant ones. From hiding internal props to limiting event handlers or restricting state actions, Exclude keeps types precise, modular, and aligned with real-world usage.
4 min read
Jan 07
Advanced Union Type Techniques in TypeScript — 01 Extracting Types

Advanced Union Type Techniques in TypeScript — 01 Extracting Types

The Extract utility type in TypeScript lets you carve out specific members from a union, aligning types with real-world logic. From filtering text inputs to isolating premium product options or refining state in React, Extract helps create cleaner, safer, and more maintainable code.
4 min read
Dec 18
Why Being Chill All the Time Isn’t Always Cool: The Chaos of Complacency

Why Being Chill All the Time Isn’t Always Cool: The Chaos of Complacency

Complacency is a silent life-drainer that seeps into routines, relationships, and work, turning vibrant days into dull repeats. Breaking free starts with a decision to act, set boundaries, and pursue purpose. Life is too rich to live on autopilot—take the wheel and drive it forward.
6 min read
Dec 07
TypeScript Error Handling: A Closer Look into Custom Error Objects

TypeScript Error Handling: A Closer Look into Custom Error Objects

By re-creating errors from different sources with a consistent factory function, you can standardize formats, ensure predictable handling, and centralize customization. This pattern makes complex TypeScript apps easier to maintain and adapt as services and requirements evolve.
4 min read

Subscribe to our newsletter.

Become a subscriber receive the latest updates in your inbox.

Popular Topics

Web Development (24)
Software Development (22)
JavaScript (19)
Software Engineering (19)
Technology (17)
Psychology (16)
Productivity (14)