AI Agent Developer
Hi, I'm

Flora You.

You Yujing · 尤钰菁

From software testing to embedded development, and now to AI agents
—— always becoming a better engineer, always on the way. Be a builder, learn in public.
15,000+ likes & saves on my tech content (Xiaohongshu)

Looking forward to building something together!
GitHub Contact
You Yujing leading a team session at Scania
3 yrs
Enterprise R&D at Scania
3
AI agent projects, solo-built
2
0→1 startup-stage teams
15k+
Likes & saves on tech content
About

About Me

Software engineer with nearly 3 years at Scania R&D, building production embedded systems and AI-powered internal developer tools—from delivering production vehicle middleware during the China R&D branch's 0→1 buildout to creating a RAG-based engineering knowledge assistant adopted across the high-performance team.

Recently built 3 AI agent projects end-to-end on my own — one of them, Start From JD, is deployed and publicly live. I bring hands-on experience analyzing and designing complex business systems, shipping end-to-end, and running containerized AI coding agents like Claude Code. I understand the AI agent stack deeply and can build scalable agentic systems.

M.Sc. in Applied Informatics from Xi'an Jiaotong-Liverpool University. I bring a global outlook and thrive in fast-paced, cross-functional teams.

Quick ID

  • FocusAI Agents / LLM apps
  • Core stackPython · LangGraph · TypeScript
  • PreviouslyApplication Software Engineer
  • EducationM.Sc. Applied Informatics, XJTLU
  • LanguagesChinese · English
  • RedNoteAI content creator
  • GitHubYouFlora
Moments

Moments

Leading a team session at Scania
Leading a team session at Scania
Master's graduation
Master's graduation · XJTLU
At the hackathon
At the hackathon
Hackathon demo pitch
Hackathon demo pitch
Experience

Work & Education

May 2023 — Dec 2025

Application Software Engineer

Scania R&D (Jiangsu) Co., Ltd. — Shanghai Branch
  • As one of the early engineers in the China R&D branch's 0→1 buildout, built the instrument-cluster middleware from scratch to relay vehicle data to the Android and GUI layers, delivering the in-house DDU software into production.
  • Designed and built an AI knowledge-base Q&A assistant for the team, serving 52 core high-value users and accumulating 2,312 professional documents, 1,137 curated QA entries, and 1,250 structured terms—breaking down departmental knowledge silos.
Agent and embedded engineering Complex-system analysis & designInterface / tool integrationRequirements → reliable pipelinesEnd-to-end deliveryCross-functional work in English
Sep 2021 — Apr 2023

M.Sc. in Applied Informatics

Xi'an Jiaotong-Liverpool University · Sino-foreign joint venture, taught in English
Jul 2019 — Jul 2020

Software Test Engineer

Dreame Technology · joined at startup stage
  • Joined at the startup stage; designed and executed full-lifecycle test cases (development to launch) for 6 consumer hardware products. Distilled the probing of product boundaries and edge cases into reusable testing methods, now carried over to the exploration and evaluation of LLM / Agent capabilities.
Reusable eval methodologyBoundary / edge-case testingRegression suitesFailure-mode analysisQuality-bar ownership
Sep 2015 — Jun 2019

B.Eng. in Internet of Things Engineering

Jinling Institute of Technology
Projects

Projects

01

Coding Agent Runtime Prototype

Personal AI Project · 2026-01 – 2026-06
  • Independently designed and built a Coding Agent Runtime prototype to tackle problems that Coding Agents commonly hit in real software-development scenarios: tool misuse, context overflow, long-task interruption, and over-privileged dangerous commands
  • Built a single-lead-Agent-driven ReAct execution loop with LangGraph, supporting sub-Agent spawning for complex sub-tasks with isolated contexts and git worktree file isolation
  • Designed a multi-stage "static prefix + dynamic suffix" context assembly to hit the prompt cache and cut cost; automatic compaction when context approaches the window limit
  • Applied tiered approval to high-risk actions with inherited permission boundaries (tighten-only) for sub-Agents; handled exceptions including tool failures, context overflow, user interruption, and infinite loops via Step Limit, retry backoff, checkpoint recovery, and event logging
  • Established offline evaluation and replay covering code retrieval / bug fixing / editing / command execution / multi-turn invocation / sub-Agent delegation / exception recovery, with all metrics auto-aggregated from the event stream
Python · LangGraph · Agent Runtime Source →
Architecture build-up · assembled layer by layer, M1 → M8
02

Start From JD

Live · Publicly available
  • A reverse-SOP, ATS-friendly résumé assistant: matches your verified experience to any job description and generates a clean one-page, ATS-ready résumé
  • A 5-step LLM pipeline with Zod schema validation; auto-retry with error-feedback injection keeps structured output reliable even on free-tier models
  • Two layers of anti-fabrication guardrails (system prompt + schema): it would rather trim than invent
  • BYOK design: the user's API key stays in their browser only — zero server-side persistence
Next.js 14 · TypeScript · Zod · Cloudflare Online Application→ Source →
User First 1,000+ likes & saves on RedNote Video Demo →
03

YouTube Transcript Agent

Hackathon project · Open source
  • The reason was simple: I wanted to keep up with the latest news without watching a whole long video — so I built this
  • A self-planning agent: classify → key points → generate → critique, turning a long transcript into a readable article step by step
  • Bilingual (EN / 中文), live in-browser progress, Markdown export — every run keeps a full reasoning trace
Python · LLM Agent · Planner Source →
Long video → 5-minute read · real sample
Andrej Karpathy talk video ▶ 35:00
Andrej Karpathy talk · English · YouTube ↗
~4,300 words; 35 minutes to watch in full
From "Falling Behind" to Software 3.0:
Andrej Karpathy on Agentic Coding
Summary  Since last December, the latest models just write correct code, so he rarely corrects them — and for the first time felt "behind." That leads into "Software 3.0": programming shifts from writing code to writing prompts, with the context window as the lever for steering the LLM…
Software 3.0VerifiabilityJagged intelligence vibe coding vs agentic6 sections · 8 takeaways
≈ 5-min read · a 35-minute talk, distilled into one article
Workflow

Vibe Coding Playbook

To make Vibe Coding more efficient, I refined a structured workflow that I now use consistently. The goal is simple: whenever I start a new project, I don't have to figure out what to do next. From defining requirements, building an MVP, and breaking work into manageable slices, to verification, demos, evaluation, and observability, each stage has a dedicated prompt that keeps the process consistent. I'm sharing it here in the hope that it can serve as a useful reference for others.

01 Define Requirement Clarify ›

Nail down exactly what you're building before touching code. Surface ambiguities, set measurable success criteria, and scope MVP vs. nice-to-have.

› PromptYou are a senior AI-native software engineer. Given this problem: [your problem here] Help me: 1. Identify ambiguous requirements 2. List clarifying questions 3. Define success criteria (include 1-2 measurable eval metrics I can verify against) 4. Separate MVP vs Nice-to-have 5. Estimate what can realistically be built in a 45-minute interview If an answer is not available, state explicit assumptions and move on. Keep answers concise.
02 Design Workflow Architect ›

Design the thinnest end-to-end workflow: components, data flow, APIs, and dependencies — with ASCII diagrams. Goal: a working version in 5–10 minutes.

› PromptDesign the thinnest end-to-end workflow for this problem. Output: - components - data flow - APIs - dependencies Use simple ASCII diagrams. Optimize for getting a working version running in 5-10 minutes.
03 Build MVP Skeleton Ship ›

Define the single golden-path scenario and produce a minimal runnable skeleton. Smoke-test before you tag — the skeleton must actually boot.

› Prompt — MVP skeletonDefine the golden path (the single main success scenario) and a minimal runnable skeleton. Requirements: - describe the MVP scope first (what's in / what's out) - produce only an end-to-end runnable skeleton — wiring, not feature code - mock external systems if needed - no premature abstractions - no authentication - no database unless required - if the solution includes a frontend page, make it runnable in a browser and provide the URL/opening step Goal: a skeleton that runs end-to-end; real feature code comes per-slice next. Smoke test before delivery: - after producing the skeleton, actually RUN it and exercise the golden path ONCE - show the real stdout / curl response / what you observed — do NOT infer from reading code - happy path only; just prove the skeleton boots and returns a response end-to-end - if it doesn't run: minimal fix (max 1-2 iterations), then re-run; if still broken, stop and report Gate: do NOT proceed to the GIT step until the skeleton has booted and answered the golden path once for real.
› After MVP — Git checkpoint
You are operating in a new local directory with completed MVP code. No git repository exists yet. Perform git setup only: 1. git init 2. git add . 3. git commit -m "mvp skeleton" 4. create annotated tag v0-mvp with message "MVP skeleton baseline" Constraints: do not modify source files · no extra commits · no remote push
04 Break into Slices Plan ›

Split the MVP into vertical slices — each independently runnable, user-visible, demoable, and implementable in under 10 minutes. Avoid layer-by-layer splits.

› PromptBreak the MVP into vertical slices. Each slice must: - be independently runnable - provide visible user value - be demoable - take less than 10 minutes to implement Avoid splitting by layers (frontend/backend/database). Prefer end-to-end slices.
05 Code a Slice Implement ›

Implement exactly one slice at a time. Minimal diff, no refactoring unrelated files, no design discussion — just working code changes.

› Prompt — replace N with the slice numberImplement only Slice N. Constraints: - for Slice 1, scaffold minimally; from Slice 2 on, modify existing code only - do not refactor unrelated files - keep diff minimal - return code changes only - assumptions only if strictly required for implementation (no design discussion)
06 Run, Verify & Sign-off Verify ›

Actually execute the slice — no guessing from reading code. Print a test-case table, give PASS/FAIL, then produce a demo card for the interviewer.

› Prompt — replace N with the slice numberRun and verify Slice N now — actually execute, do NOT infer from reading code. Pick the verification that fits this slice and actually DO it: - backend / CLI / script / API → run the command, show real stdout/stderr or curl response - web page / UI → actually open the page, walk this slice's flow, observe the result If it fails: perform minimal fix (max 1–2 iterations). If still failing, stop and report. Before giving PASS/FAIL, PRINT the test cases you actually ran: | # | input / action | expected | actual (real output / observed) | pass? | At least 1 case for the happy path; add an edge case only if cheap. Then give overall PASS / FAIL. Gate: a slice isn't "done" without printed test cases backed by a real execution. Demo card (for presenting to the interviewer): - what this slice added (one line) - how to demo it: where to open / what to type (exact input) / what I'll see Only list what actually passed; if it didn't run, leave it out.
› After slice — Git tag
You have just finished implementing Slice N. (change N to the actual number) Now perform git tagging only. Actions allowed: - create annotated tag v0.N-slice on current HEAD - message: "Slice N completed" Constraints: do NOT modify source code · no new commits · no remote push · only git tag command
07 Demo Handoff Present ›

Consolidate every passing slice into a single DEMO.md script you can read off live — feature list, boot command, ordered demo route, and a broken-feature flag.

› PromptI'm about to demo this app to the interviewer, but I haven't tracked slice by slice what you built. Consolidate every slice that is done AND actually passed in step 6 into a single demo script I can read off and click through end to end. Write the whole script to DEMO.md. It must contain: 1. Feature list: one line per completed slice — what it added + which file holds the code. 2. How to start: one command to boot the server + the URL to open. 3. Demo route (ordered for presentation), each step gives: - action: which URL / where to type / what to type (quote it exactly) / which button - what I'll see: what actually appears on screen (one line) - what to say: one line I can say to the interviewer 4. Flag anything broken: if a slice didn't pass, call it out — don't let me demo a broken feature live. Only describe features that were actually built and verified; do not put unimplemented work in the demo route. When done, save/overwrite DEMO.md and tell me its path and how to open it.
08 Eval Design Evaluate ›

Design a lightweight evaluation strategy for the AI workflow: 5 test cases, expected behavior, failure modes, and metrics — interview-sized.

› PromptGiven this AI workflow: [paste architecture] Design a lightweight evaluation strategy. Include: - 5 test cases - expected behavior - failure modes - metrics Keep it interview-sized.
09 Observability Monitor ›

Define the production metrics you'd collect — grouped by latency, quality, reliability, and cost.

› PromptWhat production metrics would you collect for this system? Group by: - latency - quality - reliability - cost
Skills

Skills

Agent

  • LangGraph
  • LangChain
  • ReAct
  • MCP
  • BERT fine-tuning
  • Prompt / Context Engineering

AI-Native Dev

  • Claude Code
  • Codex
  • Cursor
  • Multi-model routing
  • OpenRouter cost optimization

Web / Infra

  • Next.js
  • React
  • Docker
  • Cloudflare Pages
  • RESTful API
  • Git

Programming Languages

  • Python
  • TypeScript / JavaScript
  • C++

Embedded / Systems

  • QNX
  • AUTOSAR Adaptive
  • SOME/IP
  • Vector DaVinci