AI-Native Product Engineer

About the role

Toshiba Global Commerce Solutions is seeking a Principal AI-Native Product Engineer. This is a builder seat with a senior architect's responsibility hidden inside it. You write code, ship code, and own the result. You also own the foundation that everything else gets built on. You run multiple agentic work streams in parallel. Requirements get clarified with code. UX gets built in code. Tests get generated in code. Documentation gets emitted from code. The whole lifecycle compresses around real, executing software running on an architecture that scales. You are not handed a design and asked to build it. You are handed a problem and you build the answer. The answer includes the working architecture, the working UX, the working code, the working tests, the working telemetry, and the working release. All of it ships together because all of it was built together. If you have been waiting for a job where strong architecture and fast delivery stop being in tension, this is it. Architecture That Scales AI Generation AI generation is a multiplier. It multiplies whatever foundation it runs on. A clean architecture turns concurrent AI generation into a force multiplier. A weak architecture turns it into a tech debt accelerator at three times the speed. This seat is responsible for keeping the foundation strong enough that every agent run, across every concurrent stream, produces composable, testable, mergeable code. You will be expected to hold the architectural line. That means: SOLID is non-negotiable. Single responsibility, open-closed, Liskov substitution, interface segregation, dependency inversion. Code that violates these is code that AI cannot safely extend at scale, especially across parallel work streams. Clear module boundaries with explicit contracts. Services own their data. APIs are versioned. Schemas are typed. Side effects are isolated. Every seam an agent might touch is well-defined. This is what lets three sessions run in parallel without colliding on intent. Composability over cleverness. Small, single-purpose components. Predictable inputs and outputs. Pure functions where they fit. Stateful logic walled off behind clear interfaces. Contract-first design. OpenAPI, AsyncAPI, typed schemas, and shared data contracts come before implementation. Agents and humans both build to the contract. Contracts are the coordination mechanism across streams. Tests as architectural guardrails. Every contract has a test. Every public interface has a test. The test suite is what lets parallel AI streams iterate without breaking the foundation. Observability built in from the start. Structured logs, metrics, and traces are part of the build, not a follow-up sprint. Every feature is observable end to end before it ships. Design for change. Features get built, refactored, and replaced quickly. The architecture survives because the seams hold. You will reject AI-generated code that compromises the foundation, even when it appears to work. Working code at the cost of architectural rot is a net negative, and that cost compounds across concurrent streams. The leverage of this seat depends on a foundation that compounds, not erodes. End-to-End Delivery, With the Architecture Intact You own the feature from intent to production. Speed is mandatory. Quality is mandatory. They are not in tension when the foundation is right and the streams are isolated. Stakeholder problem, clarified in code and conversation. Architecture and contracts established before implementation runs at scale. Backend, frontend, APIs, data, and integration changes implemented with agentic acceleration on top of clean abstractions. UX built in code, in flow, validated against the running build. Tests generated alongside implementation, verified deterministically. Security, performance, observability, and release readiness designed in, not retrofitted. Telemetry watched after release. Issues fixed. Learnings fed back into contracts, skills, and architecture. Authentic Development Execution This role rejects pseudo-work. You will not spend your week producing wireframes that nobody implements, requirements docs that nobody reads, or design reviews that nobody can verify. The work is the code. The code is the work. You write real code in real branches against real production systems. You merge PRs. You do not merge slide decks. You deploy. You watch the telemetry. You fix what the telemetry tells you to fix. Your output is measured by what shipped, what works, and what users actually used. Not by activity, not by tickets closed, not by meetings attended. You will be judged on what runs in production with your name on it. UX Built In Code, With AI, During Implementation UX in this role is a build activity, not a pre-build activity. You will not produce Figma files for a separate team to implement. You will not run design reviews for screens that do not exist yet. You build the screen, the flow, the validation, the empty state,

Your Match

How well this role fits your profile.

Company Intel

What employees say

Worked at toshibaglobalcommercesolutions? Share your experience