[Hiring] Senior Software Engineer @Kantiv (formerly Joist AI)

Role Description

We’re looking for a strong software engineer with roughly 4–5 years of experience to play a central role in our chat team. You’ll help shape the team’s technical direction, own the system design of day-to-day projects, maintain a high bar for engineering quality, and support junior developers through thoughtful design guidance and code reviews. This is a hands-on role for someone who combines strong programming fundamentals with practical experience building agentic systems.

What you’ll do

• Own the technical design and delivery of chat-team projects.
• Shape engineering priorities, standards, and day-to-day technical decisions.
• Turn product requirements into simple, maintainable system designs.
• Write production Python and remain closely involved in implementation.
• Design clear abstractions that reduce complexity without over-engineering.
• Review pull requests for correctness, maintainability, test coverage, and overall design quality.
• Help junior developers strengthen their programming and system-design judgment.
• Diagnose production issues across application code, agent workflows, prompts, models, data, and infrastructure.
• Improve the reliability, observability, latency, and cost of our chat systems.
• Take initiative in making the team more AI-native by improving how we use coding agents throughout the development lifecycle.
• Mentor other engineers in effective agentic coding workflows, including planning, implementation, testing, debugging, and code review.

Qualifications

• Approximately 4–5 years of professional software engineering experience.
• Strong proficiency in Python, including writing idiomatic, typed, testable, and maintainable production code.
• Strong programming fundamentals and consistently sound engineering judgment.
• Experience designing, delivering, and operating production systems.
• An ability to create useful abstractions while keeping systems simple and understandable.
• Strong knowledge of API design, data modeling, concurrency, error handling, and observability.
• Experience writing effective automated tests with tools such as pytest.
• The ability to review code beyond surface-level concerns and explain the reasoning behind suggested changes.
• Experience mentoring junior developers and improving the quality of their work.
• Comfort taking ownership, identifying opportunities, and driving improvements across a team.
• Clear written and verbal communication.

Requirements

• Agentic systems experience.
• Hands-on experience building LLM or agentic applications is required. Relevant experience may include:
• Building tool-calling or multi-step workflows using LangGraph or a comparable agent framework.
• Designing conversation state, context management, and execution flows.
• Working with model APIs, structured outputs, retrieval, and grounding.
• Supporting streaming responses and asynchronous execution.
• Evaluating prompts, models, and end-to-end agent behavior.
• Instrumenting and debugging LLM applications with Langfuse, LangSmith, or similar observability platforms.
• Managing the reliability, latency, and cost of production LLM systems.
• We do not expect expertise in every named tool. We care about the underlying engineering judgment and the ability to learn or replace frameworks as the ecosystem changes.
• Agentic coding experience.
• The candidate should be a power user of agentic coding workflows and understand how to use coding agents as engineering tools rather than simple code generators.
• Use coding agents effectively across exploration, planning, implementation, testing, debugging, and review.
• Provide agents with the right context, constraints, and verification steps.
• Critically evaluate generated code for correctness, security, maintainability, and unnecessary complexity.
• Design development workflows that keep engineers accountable for the resulting code.
• Identify repeatable team workflows that can be improved through agents and automation.
• Teach junior developers how to use coding agents effectively without weakening their engineering fundamentals.
• Lead practical initiatives that make the team faster and more AI-native.

What success looks like

• The team makes clearer and more consistent technical decisions.
• Projects have simple designs, well-defined boundaries, and useful tests.
• Code reviews catch meaningful design and correctness issues early.
• Junior developers receive actionable guidance and grow more independent.
• The team develops effective and responsible agentic coding practices.
• Production issues become easier to diagnose and resolve.
• The codebase becomes easier to understand, change, and operate over time.