YL.

Hi, I'm Yingchen

Senior full-stack engineer turning ambiguity into systems that scale.

For 10+ years, I've turned vague product requirements into clear system designs—defining boundaries, making trade-offs explicit and aligning web, mobile, backend and cloud around one reliable delivery path.

Since late 2025, I've used AI as an engineering multiplier—from Cursor and Claude Code to Codex agent teams—without delegating architecture, security or evidence. It has helped ship Mapify to 5M+ users, share AxIT metrics across four runtimes, cut Aimi startup by 52% and automate work once handled by 30 staff.

View selected workRésumé
#ways-of-working

From Ambiguity to Architecture

AI-assisted engineering · since late 2025

From coding assistant to an engineered AI team.

This is engineered vibe coding: my workflow evolved from asking AI for code to designing the context, guardrails and verification that let several assistants work safely on real products.

  1. 01

    Cursor

    Pair programming

    Used assistant coding to explore and implement Mapify changes faster while keeping system boundaries and review decisions explicit.

  2. 02

    Claude Code

    Engineered guardrails

    Added project instructions, behavioural specifications, plans, design rules, reusable skills and verification around Mapify and Henri.

  3. 03

    Codex agent teams

    Parallel delivery

    Now coordinate isolated agents and worktrees across AxIT research, implementation and testing without blurring evidence or acceptance.

AI accelerates implementation. Judgement still shapes the system.

I make the difficult parts concrete before they become expensive: what success means, where the boundaries belong, which trade-offs are acceptable and how the team will know the result works.

  1. 01

    Frame the real problem

    Turn incomplete requirements into outcomes, constraints, unknowns and acceptance boundaries the whole team can challenge.

  2. 02

    Design the trade-offs

    Choose boundaries, ownership and failure behaviour deliberately—and document why one option won over another.

  3. 03

    Build the delivery system

    Connect specifications, evidence and repeatable checks so the system and the team can evolve without relying on tribal knowledge.

AxLib + SBN Testing · Engineering ↔ QA

01

Separate algorithm confidence from app acceptance

Domain experts have limited time, while app testers should not have to recompute formulas. I designed two review phases: de-identified AxLib comparisons focus expert attention on algorithm differences; SBN Testing then lets the wider team verify observable behaviour against the exact build.

Less context loss · clearer ownership · auditable decisions

Read more

Mapify · Delivery system

02

Make speed and release confidence reinforce each other

I reduced CI builds from more than an hour to about 20 minutes, introduced a production-like pre-release environment, and added deployment requests, release templates, checks and confirmations. Parallel uploads and deployments made the path faster without making it less deliberate.

Faster feedback · fewer late surprises · safer releases

Mapify + Henri + AxIT · AI-assisted engineering

03

Use AI as an engineering team—not a shortcut

I treat AI assistants like capable junior engineers: give them context, constraints and reviewable plans; let them accelerate implementation; then apply senior judgement to architecture, security, performance, technical debt and acceptance. I also document and share the practice so the team can reuse it.

Faster iteration · durable context · human judgement stays in charge

#projects

Selected Work

🧠 15M+ mind maps generated

Mapify

Led development of Xmind's AI knowledge platform, used by 5M+ people to turn documents, media and web pages into clear visual maps. I translated product requirements into system boundaries across ingestion, summarisation, search, growth and release operations. This moved vibe coding into an engineered practice: Cursor and Claude Code accelerated implementation and review inside documented architecture and release guardrails.
  • System & Product Design
  • Search & Data Systems
  • Architectural Trade-offs
  • AI-assisted Delivery

Read more · technical case studies

Mapify
  • 01

    Search migration without a hard cut-over

    Designed full-text mind-map search, then balanced migration speed against release risk with a user-transparent S3-to-PostgreSQL rollout and fallback behaviour.

  • 02

    One contract for every summarisation surface

    Re-architected AI summarisation, mind-map generation and persistence behind a shared package so web, backend and Zapier could evolve without producing different results.

  • 03

    Growth infrastructure without template drift

    Architected generated TypeScript email templates, dynamic lists, click tracking, unified unsubscribe and one-ZIP locale imports.

  • 04

    Revenue features without sacrificing speed

    Built affiliate contracts, one-step Stripe coupons, tiered commissions and refund-aware settlement; cut FCP from 11.6s to 1.1s and LCP from 22.1s to 7.6s.

🎓 Personal AI tutor

Henri

Led Henri, an AI product built using AI, from an open-ended promise—teach any topic—to a production learning system. I defined the knowledge model, orchestration boundaries and release path behind its conversational lessons, active recall and adaptive quizzes. It also became my proving ground for engineered vibe coding: Claude Code worked inside project rules, behavioural specs, design tokens, plans and tests—not instead of them.
  • Problem Framing
  • AI System Design
  • LLM Orchestration
  • Engineered Vibe Coding

Read more · technical case studies

Henri
  • 01

    Turn any topic into a coherent learning path

    Designed knowledge trees, personalised syllabus generation, conversational chapters, active-recall quizzes and learning reminders.

  • 02

    Real-time AI with explicit failure boundaries

    Stabilised streamed LLM responses and generated-image pipelines while expanding automated coverage and internationalisation.

  • 03

    One path from model call to App Store

    Delivered the production path across AWS, S3, PostgreSQL, iOS/TestFlight and release configuration.

📱 Connected strength assessment

AxIT

Turned domain-heavy strength science into connected product architecture: Push-IT, Pull-IT and Stomp-IT traces become live feedback, comparable metrics and reports across mobile, web and backend systems. I now apply engineered vibe coding through Codex agent teams and isolated worktrees, researching, implementing and verifying changes in parallel while keeping evidence and release acceptance distinct.
  • Domain & System Modelling
  • Kotlin Multiplatform
  • Cross-platform Trade-offs
  • AI-agent Delivery

Read more · technical case studies

AxIT
  • 01

    A domain-heavy product, usable at 700+ centres

    Built the original Android and Bluetooth foundation plus backend services for connected strength assessment.

  • 02

    Share the calculation contract—not every app

    Chose Kotlin Multiplatform for AxLib's models, capability rules, sampling and metrics while keeping platform-specific UI, Bluetooth and performance decisions in iOS, Android, Connect web and backend services.

  • 03

    Separate algorithm review from app QA

    Connected de-identified AxLib trace exploration to SBN Testing's exact-build plans, shared evidence, immutable history and discussions so engineering, QA and release owners work from the same record.

Earlier work

More products, less scrolling

OptuSafe product preview

OptuSafe

Turned stakeholder, security, budget and availability constraints into a clear identity-platform architecture and delivery plan.

Product discovery · System design · GCP

Airtasker product preview

Airtasker

Redesigned backend and Android workflow boundaries, cutting loading by more than 50% and improving retention by 17%.

Service design · Mobile systems · Performance

#experiences

Where I've Worked

Contract Work

Independent Software Contractor

Aug 2026 - Present
  • AxIT iOS: through weekend contract work, build and modernise AxIT with Swift and SwiftUI, bringing its Bluetooth-connected assessment, session, sync, reporting, and release workflows to iPhone and iPad
  • Cross-platform metrics: contribute AxLib's shared calculation contract across iOS, Android, Connect web and backend services while keeping UI, Bluetooth and performance decisions platform-specific
  • AI-assisted metric review & QA: apply engineered vibe coding through Codex agent teams and isolated worktrees to evolve de-identified trace exploration and SBN Testing's exact-build workflows, separating algorithm review from app-behaviour testing with auditable evidence
Xmind

Senior Full-Stack Engineer @ Xmind

Jan 2025 - Jul 2026
  • Led development of Mapify, turning product requirements into system boundaries across search, summarisation, data migration, growth and release operations; matured vibe coding with Cursor and Claude Code into implementation inside documented architecture, review and release guardrails
  • Designed full-text search and balanced migration speed against release risk with an S3-to-PostgreSQL index rollout, fallback behaviour and no hard cut-over
  • Built its multilingual email and affiliate-settlement systems, and cut homepage FCP from 11.6s to 1.1s and LCP from 22.1s to 7.6s for a product trusted by 5M+ users
  • Led development of Henri, turning the open-ended promise of teaching any topic into an AI product built using AI and a proving ground for engineered vibe coding, from behavioural specs and design rules through testing and production
Contract Work

Independent Software Contractor

Jun 2024 - Dec 2024
  • Established the Swift and SwiftUI foundations for AxIT on iPhone and iPad across Bluetooth assessment, sessions, sync and reporting
  • Preserved compatibility with the established Android product and its Push-IT, Pull-IT, and Stomp-IT device ecosystem
Aimi

Senior Software Engineer @ Aimi

Jun 2022 - May 2024
  • Led the system design and delivery of a portable C++ generative-music engine and cross-platform SDK, reducing startup time by 52%
  • Founded the Android team and built Aimi Player with Kotlin, Jetpack Compose, and Media3
  • Built React and Next.js products and maintained AWS delivery with Docker, Terraform and GitHub Actions, while achieving 96% test coverage
Servian Consulting
Optus

Engagement Lead @ Optus

Jan - Jun 2022
  • Turned ambiguous stakeholder needs, security constraints, budget and risk into a clear architecture and delivery plan with an Agile team of three
  • Designed and built a secure, highly available solution with Kotlin, Spring Boot, React, Redux, GCP Kubernetes, Docker, and Terraform
Airtasker

Backend / Android Engineer @ Airtasker

Sep 2021 - Feb 2022
  • Built Kotlin and Spring Boot backend services that cut web and mobile load time by more than 50%
  • Developed a dynamic Android workflow with Kotlin and Jetpack Compose, improving customer retention by 17%
Lendlease

Cloud Engineer @ Lendlease

May - Oct 2021
  • Trained a Python and Pandas ticket-classification model on Vertex AI and integrated it with ServiceNow through GCP Pub/Sub, reducing manual classification work previously handled by 30 staff
  • Built MLOps delivery and a Dialogflow backend using Python and GCP Cloud Functions
Strength By Numbers

Lead Full-Stack Developer @ Strength By Numbers

Jun 2018 - Apr 2021
  • Designed and built the original AxIT Android app in Java, managing complex asynchronous Bluetooth operations with ReactiveX
  • Built Spring Boot and MongoDB synchronisation services on AWS supporting more than 700 physio and fitness centres
  • Developed React and Redux web applications and owned delivery from requirements and architecture through testing and deployment
SensiLab

Full-Stack Developer @ SensiLab

Sep 2016 - May 2018
  • Built React, Express.js, MongoDB and Firebase products, plus an iOS app in Swift
  • Optimised WordPress performance and built custom themes and plugins
#about

Behind the Work

Engineer · systems thinker · team enabler

I turn messy problems into systems people can reason about.

I still love coding, but the highest-leverage work starts before the code: clarifying what success means, surfacing constraints, choosing trade-offs and giving the team a shared model for what to build and how to prove it. Since late 2025, I've brought that approach to AI-assisted development: assistants can accelerate implementation, while sound system design keeps the speed pointed in the right direction.

  • Ambiguity → clarityOutcomes, constraints, unknowns & acceptance
  • AI-assisted since 2025Cursor → Claude Code → Codex agent teams
  • Curious since 2005A school website, then football-playing & racing robots
#contact

Let's Build Something Useful

Vague problem, clear system.

Building an ambitious AI, web or connected product? Let's make the constraints, trade-offs and delivery path clear—then build something people can trust.
Email me

Built by Yingchen with Next.js