Wu Yunhui / System Architect / Codex Development
Turning complex business needsinto dependable systems.
System Architect · Technical Leader · Full-Stack Delivery
I’m Wu Yunhui, a system architect with nearly two decades of engineering experience, including chief engineer, R&D director and CTO roles. OpenAI Codex is now my primary development partner. AI agents handle code implementation while I translate business understanding and architectural judgment into tasks, context and Skills, advancing requirements into working, verifiable systems.
Java / Go / Spring / Redis / Kafka / Kubernetes
BUILD · THINK · DELIVER
Nearly 20 years
In software engineering & architecture
30+ engineers
Engineering team leadership
AI agent collaboration
Architecture guides implementation, review & delivery
Codex development workflow
Architectural judgment.
Codex collaboration.
OpenAI Codex is my most-used development partner. AI agents now handle code implementation, while I organize requirements, project context, Skills and verification. Nearly two decades of engineering experience, including years in architecture and leadership help me decide what to build, where the boundaries belong, and how to integrate agent output into maintainable systems.
Primary development partnerOpenAI Codex
Task breakdown · Context · Skills · Implementation · Review · Verification
I remain responsible for architectural decisions, code quality and the final delivery.
- 01
Define goals and boundaries
Clarify business rules, permissions, data consistency and acceptance criteria. Break the work into tasks that can progress independently and integrate coherently.
Business goals / Architecture / Acceptance criteria - 02
Turn experience into context
Use project conventions, API contracts, existing implementations and Skills to give agents actionable engineering standards and technical constraints.
Project conventions / Skills / API contracts - 03
Let agents advance implementation
Use Codex for coding, interface updates, test additions and issue investigation. Break larger goals into clear execution units, coordinate dependencies and integration, and continually assess technical decisions.
Task breakdown / Implementation / Iteration - 04
Verify with engineering evidence
Check builds, tests, real browser interactions and runtime behavior, then confirm the delivery scope against the agreed goals.
Code review / UI verification / Delivery checks
How I organize Skills and engineering conventions
Group established methods by task, giving agents constraints that fit the technology stack, existing code and delivery goals.
Backend & data
Frontend & experience
Quality & delivery
Validate ideas sooner
Use AI to advance prototypes and implementation across applications, bringing working interfaces and inspectable behavior into discussions earlier.
Make experience reusable
Capture established practices in project conventions and Skills, reducing repeated explanation and giving subsequent tasks a consistent starting point.
Keep quality alongside speed
Include review, testing and verification in the workflow to correct agent output as development progresses.
Recent work
Exploring new technology through real engineering problems.
Recent practice spans Web3 applications, enterprise commerce and collaboration products, connecting architecture, implementation across applications, and engineering verification.
01
Web3 & On-chain / Off-chain Integration
Developing wallet identity, smart contract and business service integration across Go backends, administration tools and multilingual user interfaces.
Engineering focus
Signature authentication, transaction confirmation, retries and state consistency connect on-chain events with clearly defined business workflows.
02
Enterprise Commerce & Delivery Across Applications
Evolving Java services, administration interfaces and mobile applications around products, orders, access control and operational workflows.
Engineering focus
Existing system conventions and business rules guide API coordination, integration across applications, and release processes.
03
Architecture for Collaboration Products
Building foundations for identity, teams, access control and administration, while defining the boundaries for meeting and real-time communication integration.
Engineering focus
Modular design clarifies data ownership, API contracts and collaboration between components, supporting incremental product development and integration.
Industry practice
Technical judgment, grounded in real problems.
Connecting industry requirements with the realities of building and operating systems.
01 / Industry practiceIndustrial Safety & Risk ManagementConnecting risk assessment, work management and remediation into actionable workflows.Explore technical approachClose technical approach
- Business context
- Industry systems serving construction, hazardous-material warehousing, and pipeline storage and transport. Workflows cover risk classification, hazard remediation and verification, job safety analysis (JSA), permit-to-work (PTW), and mobile field data capture.
- My responsibilities
- Responsible for platform architecture, core development, and engineering management, supporting ongoing product iterations, module decoupling, and versions tailored to different industry needs.
- Key challenges
- Shared workflows coexist with industry-specific rules. Field data must stay coordinated with the platform, while growing functionality needs clear module boundaries and maintainable structure.
- Technical approach
- Organized industry capabilities through a modular architecture and workflow engine. Introduced caching, addressed offline data synchronization, and used distributed storage to support business records and materials.
- Engineering value
- Translated industry rules into executable, traceable processes, keeping the product structure clear as it evolved and connecting field operations with platform management.
02 / Industry practiceEnterprise Workflows & Connected TerminalsBringing business processes, terminals and backend services together across connectivity conditions.Explore technical approachClose technical approach
- Business context
- Enterprise business processes working with intelligent terminals, including terminal-to-server data exchange, authentication, device interactions, and business document handling.
- My responsibilities
- Contributed to software architecture, interface coordination, and technical problem-solving across enterprise systems and connected terminals, linking business workflows with device capabilities.
- Key challenges
- Terminals and backend services needed to exchange data online and offline, while coordinating identity, access control, and multiple peripheral interfaces.
- Technical approach
- Used message queues for terminal-to-server data exchange and supported online/offline collaboration. Integrated authentication and access management, and coordinated interfaces for capture, scanning, printing, and voice functions.
- Engineering value
- Extended digital workflows to terminal operations, aligning data exchange, identity boundaries, and field use so that enterprise systems and device capabilities could be delivered together.
03 / Industry practiceReliability Engineering for Automotive SystemsMaking every stage of data upload and log storage more dependable.Explore technical approachClose technical approach
- Business context
- Automotive-related systems handling client data uploads and cloud log processing, with support for both online and offline uploads during ongoing operation.
- My responsibilities
- Responsible for architectural modernization and performance optimization, alongside a shared microservices framework, containerized deployment, and engineering delivery practices.
- Key challenges
- Upload stalls and packet loss, communication and memory behavior, and dependable log processing and storage required attention across the full processing chain.
- Technical approach
- Introduced asynchronous processing and batched log writes, optimized communication protocols and memory management, and tuned the JVM. Built shared authentication, configuration, gateway, and tracing capabilities; supported delivery with Kubernetes, vulnerability scanning, and staged releases.
- Engineering value
- Improved stability in data uploads and log processing, creating a more consistent engineering foundation for operations, troubleshooting, and future delivery.
Industry examples are anonymized and focus on business context, technical responsibilities, and engineering approaches.
Capabilities
Business understanding. Systems depth.
Engineering experience grounds my decisions; AI agents extend my implementation capacity. From architectural boundaries to operations, I build solutions that can be delivered and evolved.
01
Business Modeling & Platform Architecture
Translate business rules into domain and module boundaries, enabling platform development and the evolution of multi-tenant products.
02
Reliability & Performance
Investigate data flows and runtime behavior, using asynchronous processing, caching, messaging, and performance tuning to address stability and efficiency.
03
Cloud Native & Engineering Delivery
Connect building, releasing, and operating software through containerization, continuous delivery, and runtime governance.
04
Technical Leadership & Engineering Management
Connect technical decisions with product goals and team capabilities, establish engineering practices, and guide collaboration and delivery.
Additional experienceBlockchain node operations, smart contract development, and integration between on-chain and off-chain systems complement my work on enterprise systems.
Technical thinking
A broad technical range. Judgment grounded in the problem.
Methods I continue to explore through engineering work and architecture discussions. Each area connects business boundaries, implementation choices and verification. Expand a topic to read more.
Architecture & Business ModelingDomains · Modular monoliths · Microservices · APIsExplore approachClose approach
- Define modules through business workflows, roles, data ownership and change patterns, coordinating through explicit interfaces.
- Choose modular monoliths or microservices to fit business complexity, team size and delivery conditions, introducing events where useful.
- Follow existing conventions and reuse mature components, controlling dependencies so the architecture can evolve.
Data Consistency & Asynchronous ProcessingTransactions · Idempotency · Retries · StateExplore approachClose approach
- Define transaction boundaries and idempotency conditions around business operations, checking the meaning of amounts, permissions and state changes.
- Separate immediate results from asynchronous steps, accounting for duplicate events, retries and stale state.
- Select transactions, locks and queues to fit the workflow; consider recovery and verification when evaluating approaches such as Outbox.
Networking & Service AccessDNS · HTTPS · Nginx · Tunnels · WireGuardExplore approachClose approach
- Distinguish the public domain, browser Origin and upstream service address, checking DNS, HTTPS, proxies and callbacks together.
- Define Nginx routing and cache boundaries by response type, accounting for APIs, cookies, static assets and persistent SSE connections.
- Use Linux networking, iptables, routing and WireGuard to reason about private access and network boundaries, tracing failures along the connection path.
Identity & Security BoundariesJWT · RBAC · Sessions · Origin · SignaturesExplore approachClose approach
- Define authorization through roles, resources and operations, enforcing permissions within server-side business boundaries.
- Consider Origin, CSRF, signatures, replay protection and session lifecycle, checking invalidation when account, network or authentication state changes.
- Separate secrets, internal data, logs and public build artifacts, including security scanning and sensitive-data checks in delivery.
Performance, Data & ObservabilityJVM · Async processing · Caching · Logs · TracingExplore approachClose approach
- Trace uploads, processing and storage together, using communication, memory and JVM behavior to investigate performance.
- Shape queries and caches around access patterns, considering historical data, offline synchronization and batched writes.
- Use logs, metrics and tracing as evidence, making test conditions and runtime observations explicit.
Cloud Native & Continuous DeliveryContainers · Kubernetes · CI / CD · Releases · RecoveryExplore approachClose approach
- Connect builds, configuration, images and deployment targets, using namespace isolation, autoscaling and staged releases where appropriate.
- Release within the agreed change scope and check running images, asset versions and service state alongside pipeline results.
- Plan persistence, backups, recovery and rollback before environment changes, then verify services and databases.
Web3 & On-chain / Off-chain IntegrationWallet identity · Contracts · Confirmation · ProjectionsExplore approachClose approach
- Define wallet, service and contract responsibilities, clarifying roles, authorization and funds flow before designing interactions.
- Check submission, confirmation and business state separately, using receipts, blocks and events to verify on-chain behavior.
- Account for wallet changes, session invalidation, asynchronous confirmation and retries, connecting chain results to business workflows.
Full-Stack Experience & CollaborationVue · React · Mobile · Languages · Team accessExplore approachClose approach
- Organize interfaces around administrator and user tasks, presenting clear navigation, permissions and business state.
- Use the browser to verify navigation, longer copy, languages, mobile layouts and failure states against real API behavior.
- Build collaboration around identity, teams, data ownership and API contracts, planning meeting and real-time communication integration in stages.
About
Two decades of experience. A new way to build.
Wu YunhuiWU YUNHUI
I began my career in hands-on Java development, building a foundation in business logic, database design, and technical problem-solving. My responsibilities grew into platform architecture, product planning, and engineering leadership, guiding teams through product evolution and establishing development and delivery practices.
Working on industry systems taught me to consider business rules, field conditions, and operational requirements together. Across offline synchronization, system integration, architectural modernization, and performance optimization, I focus on solutions that work in practice and remain maintainable over time.
Today, OpenAI Codex is my primary development partner. AI agents handle code implementation while I focus on defining problems, architecture, context and verification. Hands-on engineering and leadership experience help me identify boundary issues and translate established practices into Agent tasks, Skills and review standards, advancing ideas into working systems.
- Education
- Chongqing UniversityBachelor’s degree in Computer Science and Technology
- Professional experience
- Chief Engineer / R&D Director / CTO / System Architect
Technical writing
Recording experience. Preserving the reasoning.
My blog records practical work with Java, Go, Linux, networking and operations, preserving the approaches behind specific engineering problems.