Last month, an engineer on our team typed this into a group chat:
"Add a dark mode toggle to the settings page."
Four minutes later, a pull request appeared — implementation done, lint passing, change summary written. No IDE opened. No terminal touched.
This is Themis, an AI engineer we built in-house at PIPI. Not an autocomplete tool. Not a chatbot with code snippets. A system that reads your codebase, understands your conventions, and delivers complete pull requests from natural language — on the platforms your team already uses.
Here's how we designed it and what we learned.
The problem: a lean team across three countries
PIPI manages over 1,000 properties across Japan, Thailand, and Malaysia. We ship multiple products — guest-facing apps, owner dashboards, operations tools, channel integrations — with a remote engineering team.
Our bottleneck was never "can we write the code?" It was coverage. Too many products, too many contexts, too few hours. Althought we are an experienced engineering team, we needed AI that didn't just help individual developers code faster — we needed it to make the entire team more capable.
We adapted AI tools very early. The existing tools didn't fit. Copilot and Cursor are powerful, but they assume a developer is sitting in an IDE. Claude Code and Codex are popular only among senior engineers. Our product managers, designers, and ops team couldn't use them. We wanted anyone on the team to trigger real engineering work through the tools they already had open: Teams, Linear, GitHub, Sentry, Google Workspace.
Two-tier architecture: fast by default, deep when needed
Not every message needs a powerful AI model. "Good morning" and "what's our sprint goal?" shouldn't cost $0.15 and take 10 seconds.
We designed Themis with two layers:
Tier 1 (fast layer) handles ~80% of interactions — simple questions, status checks, casual conversation. Responses arrive in under one second at minimal cost. This runs on a lightweight model with no tool access.
Tier 2 (deep layer) activates when the request involves real engineering work: reading code, searching issues, generating implementations, reviewing PRs. Themis connects to GitHub, Linear, Sentry, and Metabase through MCP (Model Context Protocol), assembling exactly the tools it needs per task.
The handoff is invisible. Users experience it as Themis "thinking a moment longer" on harder questions. No error messages, no mode switching — just a smarter response when the question demands it.
Code generation: from message to merge-ready PR
This is where Themis diverges from every coding assistant we've used. It doesn't suggest snippets — it runs a complete engineering pipeline:
Reads your project first. Before writing a line, Themis loads your architecture guidelines, conventions, and tech stack constraints. It knows your patterns before it generates code.
Works like an engineer, not a template engine. It finds relevant files, reads surrounding context, and makes precise, targeted changes. We enforce a strict principle internally: partial changes are worse than no changes. If Themis touches something, it follows through completely.
Checks its own work. Automated lint and quality checks run before anything is pushed. Warnings are logged transparently so human reviewers see exactly what happened.
Delivers a clean PR. A well-structured pull request with a summary of changes, file list, and linked issues — ready for human review.
Every task runs in an isolated git worktree, so parallel work never collides. If something fails, it cleans up after itself. CI/CD principles, applied to AI-generated code.
Five workflows, one platform
Themis covers the full development lifecycle from a single interface:
| Workflow | What it does |
|---|---|
| Code generation | Turns descriptions into complete pull requests |
| PR review | Reads diffs and existing discussions, posts context-aware inline comments |
| Mentions | Responds to @mentions across Teams, Telegram, Linear, and GitHub |
| Bug reports | Analyzes Sentry exceptions and generates structured reports with reproduction steps |
| User stories | Converts feature requests into actionable stories with acceptance criteria |
Every agent run is tracked — duration, cost, model used, tools invoked. We know exactly what Themis does and what each run costs.
Voice as an interface
Themis supports voice messages. A product manager commuting to work can send a voice note: "Create an issue about optimizing the checkout flow." Themis transcribes, understands, executes, and replies — by voice.
This sounds like a small feature. In practice, it changed when and where our team interacts with engineering workflows. It's no longer tied to a keyboard.
The part that still surprises us: Themis built itself
Browse our git history and you'll see commits co-authored by Themis throughout the project — from voice mode implementation to admin panel features to error handling.
On its first day in production, a senior engineer submitted a PR to ensure human contributions are always tracked alongside AI's. That moment captured our design philosophy: humans set direction and maintain quality; AI handles implementation at scale.
The development cycle — generate code, review, iterate, merge — is exactly the workflow Themis was designed to enable. Dogfooding at its most literal.
What we believe
Credit: Anthropic - 2026 Agentic Coding Trends Report
We're not building foundation models or general-purpose AI infrastructure. We're doing something more specific: embedding frontier AI deeply into how a real team actually works.
Three principles guide us:
Meet people where they are. AI should come to the team's existing tools — not the other way around.
Route intelligence, don't waste it. Not every interaction needs the most powerful model. Smart routing keeps costs low and responses fast.
Ship through version control. Every AI-generated change goes through the same PR review process as human code. No exceptions.
When everyone on the team — product managers, designers, engineers — can trigger code generation, review PRs, and manage issues through natural language, AI stops being a developer's personal tool and becomes infrastructure for the entire organization.
That's what we're building.
Published in The Pulse by PIPI Inc · February 2026