Armstrong Yan

Why Sharing Myinfo Is More Than Autofill

Sun, 21 Jun 2026 18:34:32 +0800

A form asks for your name, address, nationality, contact details, income information, or family records. You have filled in some version of this form before. The service may also ask for documents, then someone or some backend process has to verify that the documents match what you typed.

Then a button appears:

Retrieve Myinfo

From the user’s point of view, this looks like autofill.

That is true, but incomplete. Autofill saves typing. Myinfo does something more important:

What Happens When You Scan a Singpass QR Code

Sun, 21 Jun 2026 18:33:32 +0800

You open a banking website on your laptop.

You click “Log in with Singpass”.

A QR code appears.

You open the Singpass app, scan the code, check the service name, approve the login, and the website suddenly knows it can let you in.

From the user’s point of view, the whole thing feels almost too simple. The QR code appears, the phone approves, the browser continues.

But the important question is:

Why Singpass Becomes National Trust Infrastructure

Sun, 21 Jun 2026 18:32:34 +0800

At first glance, Singpass looks like a login system.

You open a government website, click “Log in with Singpass”, scan a QR code, approve it on your phone, and continue. From the user’s point of view, the experience is simple. It feels like a national version of “Sign in with Google”.

But if we design such a system from first principles, it quickly becomes clear that login is only the visible tip of the system.

A Podcast Summarizer Taught Me That Summaries Are Not Understanding

Wed, 10 Jun 2026 15:43:19 +0800

Someone asked me a simple question about a project on my resume:

Did this software actually solve your problem?

It was a good question.

The project was a podcast summarizer.

The source code is public here: yanqian/podcast-summarizer.

The original idea was straightforward.

Long audio is expensive to consume.

If I could transcribe it, summarize it, and read the summary, then maybe I could understand the whole episode without spending an hour listening.

I Built a Small Harness to Stop AI Coding Projects From Forgetting State

Thu, 04 Jun 2026 10:46:50 +0800

AI coding agents are powerful.

But long-running AI coding projects break in a very specific way:

the session is interrupted
the context becomes too long
the weekly quota runs out
tomorrow’s agent forgets yesterday’s decisions
the agent changes unrelated files
the agent marks work done too early

The problem is not that AI cannot write code.

The problem is that AI coding projects often do not have durable project state.

Remote Agent Workflow

Mon, 01 Jun 2026 16:34:46 +0800

This series is about moving from mobile SSH to a durable, repository-backed AI agent workflow.

The starting point was simple: I wanted to keep local Codex work moving when I was away from my Mac.

The deeper question became:

How do I turn remote access into a recoverable, verifiable, long-running agent workflow?

Articles Link to heading

Remote Agent Workflow, Part 1: Remote Mac Terminal for Codex
Set up phone-to-Mac terminal access with Tailscale, SSH, Termius, tmux, and caffeinate.

Remote Agent Workflow, Part 1: Remote Mac Terminal for Codex

Sun, 24 May 2026 16:12:12 +0800

This is Part 1 of the Remote Agent Workflow series.

This guide explains how to control a Mac terminal from a phone and keep long-running agent tasks alive, such as Codex, automation scripts, or local development agents.

The goal is not remote desktop access. The goal is a reliable remote terminal workflow:

Phone -> SSH -> Mac -> tmux -> Codex / agent task

With this setup, your Mac becomes a lightweight remote execution node that you can access from anywhere.

Remote Agent Workflow, Part 2: From Remote Shell to Agent Control Plane

Sun, 24 May 2026 16:12:12 +0800

This is Part 2 of the Remote Agent Workflow series.

In the previous article, I built a practical remote terminal workflow:

Phone -> Tailscale -> SSH -> Mac -> tmux -> Codex

That setup solved the first problem: how to reach my Mac when I am away from my desk, and how to keep long-running local agent tasks alive after my phone disconnects.

It was useful immediately.

But after using it in practice, I found a second problem.

Remote Agent Workflow, Part 3: Turning Telegram into a Local Codex Control Plane

Sun, 24 May 2026 16:12:12 +0800

This is Part 3 of the Remote Agent Workflow series.

In the previous articles, I started with a practical remote terminal setup:

Phone -> Tailscale -> SSH -> Mac -> tmux -> Codex

That gave me a reliable way to reach my Mac from a phone.

Then I hit the next limitation: a phone is not a good terminal.

Mobile SSH is useful for emergencies, but it is not the interface I want for long-running AI development. I do not want to type shell commands, attach tmux sessions, scroll logs, and manually reconstruct state from a narrow phone screen.

Remote Agent Workflow, Part 4: In the Repository, Not in the Chat

Sun, 24 May 2026 16:12:12 +0800

This is Part 4 of the Remote Agent Workflow series.

The first layer of my remote AI development setup was connectivity.

Phone -> Tailscale -> SSH -> Mac -> tmux -> Codex

That let me reach my Mac from a phone and keep long-running local tasks alive.

The second layer was control.

Phone -> Telegram Bot -> local Codex runtime -> selected repository

That made the phone a control surface instead of a tiny terminal.

Remote Agent Workflow, Part 5: What Still Matters After Codex Mobile

Sun, 24 May 2026 16:12:12 +0800

This is Part 5 of the Remote Agent Workflow series.

When I started this remote AI development setup, the problem was practical.

I wanted to keep local Codex work moving when I was away from my Mac.

That led to the first layer:

Phone -> Tailscale -> SSH -> Mac -> tmux -> Codex

Then I realized mobile SSH was not the right daily interface, so I built a Telegram control plane:

AI-Native Software Engineering, Part 1: Mental Models in Agentic Coding

Sat, 23 May 2026 20:33:47 +0800

AI can generate code. Harnesses can validate behavior. But who builds understanding?

This is Part 1 of the AI-Native Software Engineering series.

The series asks a larger question:

When AI lowers the cost of implementation,
what remains scarce in software engineering?

This article starts with the first scarce resource:

Understanding.

Over the past few months, I’ve been experimenting heavily with AI-assisted software development.

Not autocomplete.

Not AI as a coding copilot.

AI-Native Software Engineering, Part 2: Harness Engineering and Correctness

Sat, 23 May 2026 20:33:47 +0800

Why the most important part of AI-native software engineering may not be generation, but constraint.

This is Part 2 of the AI-Native Software Engineering series.

It continues from AI-Native Software Engineering, Part 1: Mental Models in Agentic Coding.

The previous question was:

If understanding no longer comes mainly from writing code,
how do humans build mental models in an agentic workflow?

The next question is:

If implementation is delegated,
where does correctness come from?

The conversation around AI-assisted software development often focuses on one thing:

AI-Native Software Engineering, Part 3: Software as Search

Sat, 23 May 2026 20:33:47 +0800

When implementation becomes abundant, engineering starts to look less like construction and more like navigation.

This is Part 3 of the AI-Native Software Engineering series.

It continues from AI-Native Software Engineering, Part 2: Harness Engineering and Correctness.

The first article asked:

How does understanding form when implementation is delegated?

The second article asked:

How does correctness form when generation is cheap?

This article asks:

If implementation keeps getting cheaper,
what are engineers actually doing?

Here, constraints shift meaning.

AI-Native Software Engineering, Part 4: Human Judgment Against Vibe Coding

Sat, 23 May 2026 20:33:47 +0800

You can automate implementation. You can automate evaluation. But judgment remains stubbornly human.

This is Part 4 of the AI-Native Software Engineering series.

It continues from AI-Native Software Engineering, Part 3: Software as Search.

The first article asked how understanding forms.

The second asked how correctness forms.

The third argued that software is starting to look like search.

This article pushes back on a dangerous misunderstanding:

If we have agents, harnesses, and constraints,
software can produce itself.

That is not true.

Understanding Singapore's Payment Stack: From Bank Apps to SGQR, PayNow, FAST, Contactless, and NETS

Mon, 11 May 2026 00:00:00 +0000

If you live in Singapore, you probably use these payment methods every day:

You send money to a friend via PayNow.
You scan a QR code at a hawker stall.
You tap your card or phone at a supermarket.
You use NETS at a local merchant.

They look similar from the user side, but underneath they solve different problems.

The Big Picture Link to heading

Building a Private-to-Public Publishing Pipeline with Obsidian, Hugo, and GitHub Pages

Fri, 08 May 2026 22:48:50 +0800

I recently rebuilt my personal website around a simple idea:

Keep Obsidian as the private source of truth, and selectively publish public notes into a clean personal website.

This is less a Hugo tutorial and more a note about designing a publishing boundary between a private knowledge base and a public website.

This article documents the architecture, tradeoffs, and workflow I ended up with.

The repository names, URLs, and site pages in this article come from my own setup. If you follow the same approach, replace them with your GitHub username, repository name, domain, and navigation structure.

About

Wed, 06 May 2026 10:12:47 +0800

I am Armstrong Yan, a backend and platform engineer based in Singapore.

My work focuses on reliable backend systems, platform engineering, distributed services, and practical automation. I care about systems that remain understandable under pressure: clear interfaces, observable behavior, safe failure handling, and engineering workflows that help teams move faster without losing the ability to reason about the software.

This site is where I write public notes on backend architecture, cloud infrastructure, event-driven systems, AI-assisted software engineering, remote agent workflows, and personal knowledge systems. A recurring theme is the boundary between human judgment and automation: how repositories, feedback loops, and operating practices make complex work easier to recover, verify, and improve.

Now

Wed, 06 May 2026 10:12:47 +0800

This page is a snapshot of what I am focused on now, both in work and outside it.

Work Link to heading

I am focused on backend and platform engineering, especially reliable systems, AI-connected workflows, and the engineering habits that make complex software easier to operate, debug, and reason about.

I am also continuing to refine the Obsidian-to-Hugo publishing flow behind this site.

Writing and Tools Link to heading

Obsidian for private notes and long-term knowledge work.
Hugo and GitHub Pages for publishing.
Codex and AI-assisted workflows for engineering experiments.
Shottr for screenshots and lightweight visual annotation.

Outside Work Link to heading

I play table tennis two or three times a week. It is one of the few activities where I can feel improvement through repetition, timing, and tiny corrections.

Projects

Wed, 06 May 2026 10:12:47 +0800

Selected products and tools I built to solve real workflow problems, from visa form assistance to remote agent control planes and personal knowledge rediscovery.

Selected Link to heading

VisaPilot Link to heading

Browser extension · AI assistant · Visa forms · Chrome Web Store · Edge Add-ons

VisaPilot is a chat-first browser assistant for visa and arrival-card forms, with page understanding, guided filling, and progressive memory.

Resume

Wed, 06 May 2026 10:12:47 +0800

Profile Link to heading

Senior backend and platform engineer based in Singapore, with 10+ years of experience across distributed systems, production reliability, backend architecture, and platform engineering.

I focus on building systems that are scalable, observable, and practical to operate. My work often sits at the boundary between product backend systems and platform infrastructure: API design, asynchronous workflows, incident diagnosis, reliability improvements, and automation that reduces operational friction.