Agentic Systems Engineer

About Rangle#

Rangle is a Toronto-based consultancy building quality software for enterprise clients since 2013. We're a cross-functional team of designers, product managers, and engineers working shoulder-to-shoulder on production systems for clients ranging from startups to some of the largest enterprises in pharma, finance, and retail.

We run agentic development as a first-class practice. Not "we use AI tools," not "we're experimenting with Cursor." We've reshaped how teams compose, how delivery works, and how software gets shipped around the reality that AI has changed the math. Claude Code, MCP servers, spec-driven workflows, and durable agent judgment encoded as reusable skills are how we work day to day.

Sovereignty as capability is one of the directions we're actively moving in: helping clients own their stacks, data, and agentic control points rather than rent them. It's a direction of travel on many of our engagements, not the whole story.

About this Role#

This is a hands-on technical leadership role. You'll work on live client projects, lead the engineering side of a cross-functional team, and ship production code alongside review, pairing, and architectural work. You're in rooms with clients, designers, and product managers every week, not in a silo writing architecture docs.

You don't just ship features, though. You also build the meta-systems that let the rest of the team ship confidently: CLAUDE.md files, agent rules, Claude Code skills, MCP servers, test harnesses, codebase rules, reusable patterns. If it's a pattern the team will use twenty times, you're the one who shapes it so the twentieth time is faster than the first.

You work alongside an Agentic Managing Director (AMD) who owns the client relationship and Agentic Product Engineers (APEs) who move fast within your scaffolding. Your job is to make both of them faster, and to represent the engineering lane when the team is making trade-offs with design, product, and the client together.

Some of our engagements lean into platform engineering and client-owned infrastructure (Kubernetes, declarative control planes, GitOps-driven delivery); others sit entirely at the application layer. You don't need platform depth to join. We care more that you're an excellent technical lead, curious about where our substrate is going, and willing to pick up the specifics when an engagement calls for them.

What You'll Do#

• Ship production code on real client projects alongside the team. This is not a purely advisory seat
• Architect the systems your team is building: component patterns, data models, API shape, testing strategy, delivery pipeline. Shape architecture broadly, not enforcing one stack
• Build the meta-systems that scale the team: CLAUDE.md files, agent rules, Claude Code skills, MCP servers, reusable testing scaffolds, internal CLIs, and project templates. Contribute patterns back to our shared agentic template and knowledge repo so the next project starts further ahead
• Harden the agentic tooling your team depends on: configuration helpers, scaffolds, tests, and harnesses that verify agent outputs and keep AI-generated work within guardrails. If an agent can produce bad code on your project, the harness you wrote catches it before it ships
• Review PRs for system coherence, not just correctness. Catch the ripple effects before they ship
• Make the blueprint-vs-codebase call. Know when to build disposable (to iterate) and when to build integrated (to scale). Speed of iteration is a first-class concern, not a compromise
• Partner with designers and product managers on trade-offs. You represent the engineering lane at the same table, not downstream of it
• Pair with APEs while architecture is still forming, coach them on architectural thinking, and hand off cleanly once the pattern is established. Surface trade-offs to the AMD with enough clarity that they can decide quickly
• Spot bottlenecks early and build the unblocker before anyone asks
• Push back in client conversations when the ask doesn't match the goal, including advocating for client ownership over vendor lock-in when that serves them better
• Reach into the platform layer when the engagement calls for it (Kubernetes, declarative infrastructure, GitOps), without making it the center of the role

How We Work#

• Cross-functional from day one. Every delivery team ships with designers, product managers, engineers, and agile practitioners working together. You won't be translating between silos or inheriting decisions downstream. You'll be in the room where trade-offs get made.
• Lean agile, low process. One- or two-week sprints, regular demos, continuous client feedback. We value working software and direct conversations over documents and ceremonies.
• Project rotation and variety. Nobody stays on a single engagement forever. Roughly six to eight months on average, with a two-year ceiling. You'll work across industries, codebases, and client contexts rather than calcifying on one stack.
• Remote-first. Headquartered in Toronto, working wherever trust and output can flow.
• Client-facing, not client-owned. You'll talk to clients regularly alongside a project lead, but you won't carry the commercial weight of the engagement on your own.

Qualities That Will Help You Thrive#

• Systems thinker. You see how pieces fit, where changes ripple, what breaks six months from now
• Taste. You know good from great. UI, architecture, prose, API design; you hold a standard
• Agentic-native. Claude Code (or equivalent) is a primary tool, not a novelty. You encode team judgment in rules and skills, not just one-off prompts
• Low ego, high standards. You multiply the team. You'd rather ship a teammate's PR than your own if it moves the project further
• Client-ready. You can sit in a room with a VP and explain a trade-off without dumbing it down or geeking out
• Bias toward the meta-system. You'd rather invest two days in a pattern that saves five days of repeated work than ship the first instance fast

Qualifications#

Required#

• 5+ years of production software experience, with architectural ownership on at least two non-trivial systems
• Strong application-layer proficiency in TypeScript and React (or a clear path to fluency from a comparable modern stack)
• Deep experience with data. You've worked across multiple database types (relational, document, KV, time-series, search, vector, etc.) and understand how the choice of data model shapes the system. Schema design, migrations, indexing, and performance are second nature regardless of the engine
• Deploying and operating backend systems in production. You've taken services from "runs on my machine" to "runs reliably for real users." Observability, failure modes, deploys, rollbacks, incident response. You've lived in the loop, not just consumed a managed service that hid it from you
• Demonstrated agentic fluency: daily use of Claude Code, Cursor, or equivalent, with real examples of agent configuration (rules, skills, MCP servers, subagents)
• Comfort in client-facing technical conversations. You can hold the room without taking it over
• Track record of making others faster: mentorship, internal tooling, pattern libraries, OSS contributions, or written practice

Bonus#

None of these are required. Most ASEs pick them up on the job when an engagement needs them; equivalents welcome because we care about the shape of the experience more than the specific tool.

• Kubernetes or comparable container orchestration (Nomad, ECS, Docker Swarm). You've deployed and debugged real workloads, not just read about them
• Platform-engineering experience: declarative infrastructure (Terraform, Pulumi, Crossplane, Helm) and GitOps (Flux, Argo, or similar)
• Experience with long-running workflow orchestration (Temporal, Airflow, or custom) and event-driven architectures (NATS, Kafka, RedPanda, etc.)
• A systems or backend language alongside TypeScript. Go is especially useful on our platform tooling, but Rust, Elixir, Python, Java, or similar all signal the breadth we value
• Event-sourced architectures or CQRS patterns
• Experience running production on bare metal or non-hyperscale clouds
• OSS contributions to agent tooling or platform frameworks; MCP server development; Claude Code skill authorship
• Public writing on platform engineering, sovereignty, or agentic practice

Technologies We Use and Teach#

We're pragmatic about stacks: the right tool for the context. You don't need to know all of these on day one; we teach what you don't.

Agentic Layer#

Claude Code, MCP, and the Claude Agent SDK are daily tools. We invest heavily in durable team judgment, encoded as skills, rules, subagents, and reusable patterns across our projects.

Application Layer#

TypeScript, React, and the frameworks that fit the project. Tailwind and shadcn/ui for UI, TanStack Query for client state, Vitest and Playwright for tests, Biome for tooling. PostgreSQL as our default relational database. Other backend languages are welcome: Go, Rust, Python, and Elixir all show up in our work.

Platform & Infrastructure#

On engagements where it fits, we lean into Kubernetes, declarative control planes (Crossplane and similar), GitOps (Flux, Argo), long-running workflow orchestration (Temporal), event streaming (NATS, RedPanda), identity platforms (Ory, Keycloak), and OpenTelemetry + Grafana for observability.

Deployment Targets#

Client-owned infrastructure when that serves the client (including Canadian data residency), hyperscalers when context demands it.

Why You'll Love Working at Rangle#

• AI-native by default. Claude Code and agent orchestration aren't side experiments here; they're how you ship. You use them daily, and you build the patterns the rest of the team picks up.
• Technical leadership on real products. This is a delivery role, not an advisory seat. You ship into production systems real enterprise customers use.
• Flight time, not seniority theater. We track reps and capability, not titles. Structured coaching moves strong ASEs toward AMD in ~18 months when the growth is real.
• Meta-system leverage. The internal tools, rules, and patterns you build flow across projects. A skill you write for one client unblocks three more.
• Small, high-trust teams. You know your colleagues and they know you. Accountability is earned, not performed.
• Client exposure without commercial weight. You're in the architecture conversations without carrying the P&L of the AMD.
• Frontier technology, production discipline. We use the newest stuff. No vibes-only demos.