01Statement

About me

AI full-stack engineer, class of 2026. I write backends, mini programs and AI toolchains.

2022 — 2026

Statement

I am Zhu Wenhai; friends usually call me Aether. I graduated in June 2026 from Nanchang University with a degree in Computer Science, and now work as an AI full-stack engineer at a SaaS company building smart parking, smart communities and parking-asset custody.

The work is concrete: endpoints in a Spring Boot multi-module monolith, then back and forth between a Vue 2 admin console and two WeChat mini programs, carrying a requirement from design doc to production alone. Payments, permissions and data consistency across three product lines are mostly mine.

Production is mine too: the account system, security baseline and release rollback of an Alibaba Cloud ECS host, plus remote access to the internal Gitea so colleagues can push code from home. The longer I do it, the clearer it gets that operations is not firefighting — it is writing the scripts and documents that let someone else do it.

Off-hours I work on a different question: how to make AI genuinely part of engineering rather than a faster autocomplete. I have built a RAG question-answering system, an MCP server that turns design files into implementable specs, a gateway that collapses several model providers into one endpoint, and a pipeline that feeds test cases into Yunxiao and files defects automatically. I use these tools daily, so they have to be reliable.

Two beliefs: think a requirement through before writing code, and deliver things other people can verify. Every claim in my docs points to a file and line; every change states what a human must do to see it. That is not ceremony — debugging a live system during my internship taught me that vague delivery always comes back more expensive.

Education

Nanchang University · Computer Science
2022.09 – 2026.06
School of Mathematics & Computer Science · BSc
- Transferred into CS Class 223 in Feb 2024; graduated June 2026
- Core courses: Data Structures, Computer Networks, Database Systems, OS, Software Engineering
Data StructuresNetworksDatabasesOSSoftware Engineering

Campus

Counselor Assistant · Class League Secretary
2022.09 – 2026.06
CS Class 223
- 2024.02–2026.06: transferred to CS 223, concurrently Class League Secretary
- May 2023: joined the college party branch via party school; Nov 2024: branch assistant
Student Union · Quality Development Dept.
2022.09 – 2023.09
College Student Union
- Co-organized campus development activities; owned planning and on-site execution

02AI engineering

Four AI engineering capabilities

Agents, workflows, model routing, applications — each with something shipped.

Agent Application Development

hermes kernel · all in the cloud · any device takes over

Code, services and agents all live on a cloud host, and laptop, tablet and phone degrade into web-UI clients: the kernel runs in the cloud and any screen with a browser can take over. One message from your phone dispatches work, checks progress or ships a fix — development stops being tied to one desk.

Multi-device control: the laptop uses the Desktop remote-gateway registry, the phone pins the dashboard to its home screen, the tablet becomes a second console — one kernel, one session, no environment to migrate when you switch devices
Messages as commands: one line in Feishu or WeChat dispatches work, asks follow-ups or accepts results; the agent runs in the cloud and replies in the same thread — requirements move forward on a commute or a business trip
Single-writer control plane: one master owns `state.db` and the task board, other nodes are failover rather than co-writers — co-writing tears sessions and double-dispatches tasks
Zero inbound ports: the gateway binds loopback only, reached through a Tailscale tailnet behind auth; Feishu and WeChat ride outbound long connections instead of public callbacks
Bypass command layer: a watchdog reads `/api/status` every five minutes and pushes anomalies to Feishu at zero token cost — it still restarts the service and exports a crash cause when every model gateway is down
An intermediate state on the way to AGI: models and tools still move fast, so the human keeps judgement, authorisation and acceptance while the agent does execution and bookkeeping — not hands-off automation, but semi-automatic work that can be taken over or rolled back at any moment

AI Workflow Orchestration

Standardized pipeline · local tooling

Turning "requirement → design → code → verify → docs" into a fixed track with an artifact at every step, then distilling the platforms I use into local tools — so the agent works the track instead of being re-briefed each time.

A standardized pipeline: every step has its artifact and pass criterion — design, fix log and module-state templates; weak evidence goes back, not forward
Every claim points at a `file:line`; each change ends with mandatory static checks and explicit activation prerequisites (restart / rebuild / re-login)
Local tooling · Modao: the design source as an MCP the agent can call — screenshots, widget trees, assets, tokens, so alignment need not be re-explained in prose
Local tooling · Yunxiao: test plans, run status and defects wired through, 179 regression cases execute and write back automatically; the flow is a skill, packaged once and reused

Model Gateway & Balance Management

Own gateways · magpie fork · expiry-first routing

From a balance board to three self-built platform gateways, a magpie fork that folds the board back in, and routing driven by batch expiry.

Three self-built platform gateways (WorkBuddy / Qoder / Trae) exposing Anthropic Messages, OpenAI Chat Completions and Responses from one process
Account pools: pick by remaining quota, tiered cooldowns, failover — and a doctor command that names why each account was skipped
A magpie fork, magpie plus: power-meter joins the GUI as a sidecar-driven Balance Board with batch-level expiry
routing=expiry orders accounts by the board’s batch expiry, with thin wrappers supplying runsOutAt for Qoder / Trae / CodeArts

AI Application Development

RAG · vector retrieval · multi-model backends

Shipping LLM capability to production: document parsing and chunking, embedding and retrieval, cited answers, swappable model backends.

E-commerce support RAG Q&A: FastAPI + Vue 3, full pipeline from parse → chunk → embed → retrieve → generate
Dual backend — local open models or cloud APIs — switched by config, not by code
Answers carry citations, so they can be checked and hallucination risk stays low
Docker-packaged delivery: identical environments, one command to start

03Capabilities

Capabilities

29 items

AI Engineering

Agents & MCP Tooling

Package internal capabilities as agent-callable tools, and keep them as reusable skills

Agent Runtimes & Multi-Agent Orchestration

A resident kernel, a task board, sub-agent decomposition and human takeover

AI Gateways & Protocol Translation

Anthropic / OpenAI / Responses / Gemini collapsed into one entrance, with SSE streaming, account pools and key distribution

Context Engineering & Prompt Design

Constraints, evidence and acceptance written into the context — not left to luck

Document Parsing & Multimodal Extraction

PDF, web pages, video and design files all become structured input

RAG & Vector Retrieval

Parse → chunk → embed → retrieve → generate, with cited answers you can check

AI Coding (Vibe / Spec)

Day-to-day delivery is AI-driven — intent-first for exploration, spec-first for shipping

Backend

Spring Boot + MyBatis-Plus

Endpoints inside a 1,400-file multi-module monolith, with tenant isolation, dual auth and payment callbacks

Node.js / TypeScript

Main language of the gateways and toolchains — protocol translation, streaming, CLIs

Go

The language behind the gateways and single-binary services — concurrency, SSE, SQLite, Wails desktop

MySQL & Data Governance

Multiple data sources, indexes and slow queries, tenant isolation and consistency

NestJS + Prisma + PostgreSQL

The other TypeScript backend line — modular layering, migrations and queues

Python + FastAPI

AI application backends and tooling

Redis / MQTT / Queues

Caching, sessions, rate limits and device command delivery

Frontend

Design Fidelity & Responsive Typography

From design tokens to pixel comparison — not "close enough"

Interaction Motion & Frontend Animation

Scroll, reveal and transition — while respecting reduced-motion

TypeScript & Frontend Tooling

Vite + vue-tsc + ESLint as one chain, with types following the contract

Vue 2 / Vue 3

Both the legacy admin console (Vue 2 + Element UI) and modern frontends (Vue 3 composition API)

Mobile H5 & Vant

Mobile H5 adaptation, pull-to-refresh and in-app browser quirks

WeChat Mini Programs (uni-app / native)

Cross-platform and native alike, with a working understanding of subpackages, size limits and review rules

Engineering

Linux / Docker / Nginx

Ship it yourself — build, containerise, reverse proxy, TLS

Git Workflow & Code Review

Branches, commit conventions and change notes you can verify

Gitea / Monorepo Engineering

Self-hosted source control, workspaces and pipelines behind one entrance

Linux Server Operations & Security Baseline

Account systems, SSH hardening, release rollback and audit sweeps — all scripted

Tailscale / Headscale Mesh Networking

Opening internal services to home and the road with zero public ports

Test Automation

Three-target regression (API / web / mini program) with results written back to the test platform

General

English (NECCS)

National English Competition for College Students — National Second Prize

Mathematical Modeling

APMCM Asia-Pacific Mathematical Modeling Contest — National Third Prize

Technical Writing & Standards

Turning tacit experience into documents someone else can follow — ops manuals, design specs, collaboration protocols