Contract Product Engineer Jobs in Raleigh, NC (NOW HIRING)

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, the error state, and the accessibility behavior directly, in code, with AI assistance, while the feature is being implemented.

The workflow looks like this:

• Sketch in code. Stand up a working component or page. Let the AI generate the first pass against your design tokens, component library, and accessibility rules.
• Iterate against running software. Click through it. Adjust. Have the AI refactor. Repeat until it behaves the way users need.
• Validate with stakeholders against the running build, not against a static mock. Decisions are made on real interactions.
• Codify what worked. Roll repeated UX patterns back into shared components, prompts, and skills so the next feature inherits them.

You should be comfortable making UX calls in real time, in code, with AI in the loop. If you need a separate design phase to feel productive, this seat will frustrate you.

AI Onboarding

Your first 30 to 60 days are an onboarding into the agentic environment, not just the codebase. You will be expected to ramp on the platform fast and reach concurrent multi-stream operation early.

Expect to:

• Get hands-on with the internal AI developer portal, the agent registry, the prompt flow library, the RAG service, and the skills catalog within your first week.
• Read existing skills, prompt flows, and architectural contracts the way a traditional engineer reads existing code. They are the institutional knowledge of how features get built here.
• Pair with senior engineers on real agentic delivery in week one. No shadow projects. You ship inside the first two weeks.
• Configure your local agentic stack: Claude Code with worktrees, MCP servers, tool integrations, test agents, review agents, and telemetry hooks.
• Move from single-session to concurrent multi-stream operation by the end of your first month. Three sessions in flight, three features at different stages, one architecture held steady.
• Author your first reusable skill or prompt flow inside your first 30 days, contributed back to the shared catalog.
• Ship at least one customer-visible feature, end to end, inside your first 60 days, with full evidence of agentic leverage, parallel execution, and clean architectural fit.

The Tooling You Will Run

This is the working stack. Comfort and curiosity across this surface area matters more than expertise in any single tool.

• Agentic coding environments: Claude Code, Cursor, Codex, Copilot, and equivalents. You will use these every day, often three or more sessions at a time.
• Git worktrees and session isolation: the foundation for parallel multi-stream work. Each agent session gets its own working directory and its own branch. No file-state interference.
• Plan mode and auto-accept mode: two distinct execution patterns. Plan first for core business logic. Auto-accept on safe edges. Choose deliberately, not by default.
• Agent orchestration: an internal multi-agent platform that runs requirements, architecture, implementation, test, review, and release readiness agents in coordinated swarms inside each stream.
• MCP and tool integrations: you will read and write MCP tools to expose internal systems, data, and operations to your agents.
• Skills and prompt flows: a shared catalog of reusable agentic capabilities, including verification skills that teach agents to check their own work. You consume them and you contribute to them.
• RAG and knowledge retrieval: an internal RAG service that grounds agents in product, code, and operational context. You will configure indexes for your domain.
• Contract tooling: OpenAPI, AsyncAPI, JSON Schema, typed clients, contract tests. The contracts are what allow agents to safely extend the system in parallel.
• CI/CD and quality gates: deterministic pipelines that verify everything the agents and you produce. Tests, scans, contract checks, performance checks.
• Telemetry and observability: production signals that close the loop from shipped feature to actual outcome.

Agentic Swarms You Will Orchestrate

Inside each work stream, daily work runs through agentic swarms. You direct them. You do not babysit them. You give them context, including the architectural constraints, and you reject anything that fails the bar.

Typical swarm participants:

• Requirements clarifier
• Architecture and contract design agent
• UX implementation agent that works in code, against your component library and design tokens
• Backend implementation agent
• Frontend implementation agent
• Test generation and execution agents
• Code review and security review agents, with architectural fit as a hard gate
• Release readiness and risk agents
• Telemetry and post-release analysis agents

Rule of the seat: no agent self-certifies its own output, and no agent ships code that compromises the foundation. Every agent action passes through a reviewer, deterministic verification, or both. The human in the seat owns the final call across every stream.

Skills, Prompts, and Reusable Capability

The leverage in this role comes from compounding capability, not from one-off heroics. Every feature you ship should leave behind reusable assets, both code and agentic, for the next feature, and for every parallel stream that comes after.

• Author new skills and prompt flows when you find a pattern worth repeating.
• Invest in verification skills. They teach agents to check their own work and are the highest-leverage agentic asset in the system. Engineering teams at top-of-class AI solution providers consider spending a week polishing one to be absolutely worth it.
• Refactor and improve existing skills when you find sharp edges.
• Contribute MCP tools that expose new systems to the agent fleet.
• Treat the skills catalog like a first-class codebase. PRs, reviews, versioning, tests, documentation.
• Encode architectural standards into skills and prompts so that agentic output across every stream inherits the right defaults.
• Measure your contribution by how often other engineers reach for what you built.

Documentation as Build Output

Documentation in this role is not a separate writing project. It is emitted from working software.

• API docs are generated from contracts and verified against running services.
• Architecture notes are generated alongside implementation, then reviewed for accuracy.
• Runbooks and release notes are produced by agents from the actual change set, not from a parallel narrative.
• Onboarding docs for your feature are produced as part of shipping it, not as a follow-up sprint.
• If a doc does not match the code, the doc is wrong. The code is the source of truth.

Test, Verify, Release

Agents accelerate. Deterministic systems verify. Architecture makes both possible. You are accountable for all three, across every stream.

• Use AI to generate unit, integration, contract, UI, and regression tests alongside the implementation.
• Run real test suites in real pipelines. No simulated green checks.
• Use AI to identify edge cases, regression risk, and performance hot spots, then verify them with deterministic checks.
• Prepare release readiness evidence as a build artifact: scope, risk, results, rollback, monitoring, security posture.
• Watch your feature in production after release. If telemetry says it is not working, you fix it.

What Good Looks Like

• Multiple features ship per week, in parallel, without architectural regression.
• The architecture gets stronger with each feature, not weaker.
• Agent-generated code is composable, testable, and mergeable because the seams are right.
• Stakeholders describe the business outcome. The thing you shipped matches it.
• Features move from idea to production in days or weeks, not quarters.
• UX behaves correctly because you built and validated it in code.
• Tests, docs, and release evidence all exist because they were produced by the build, not after it.
• Agents produce real leverage. Deterministic systems prove the work. Verification skills catch what would otherwise leak.
• You leave behind reusable skills, prompts, contracts, and components that make the next feature faster.
• PRs are focused, reviewable, and tied to acceptance criteria.
• Engineering throughput goes up. Hidden rework does not.
• You ship what previously required a pod, on a foundation that compounds.

Required Qualifications

• 8+ years of professional software engineering experience.
• Deep fluency with SOLID principles, clean architecture, separation of concerns, and design for testability. Able to defend architectural calls under pressure.
• Track record of building systems that other engineers, and now AI agents, can safely extend in parallel.
• Strong full-stack delivery background across frontend, backend, APIs, data, and integration.
• Experience with contract-first design using OpenAPI, AsyncAPI, JSON Schema, or typed schema systems.
• Hands-on experience with AI-assisted or agentic development tools such as Claude Code, Cursor, Codex, or Copilot. Comfortable running multiple concurrent sessions in worktrees, or able...