Must-have skills
Go Lang
3 Year(s)
Aws
3 Year(s)
Claude
3 Year(s)
Language required
English
About the Role
We're hiring a Full-Stack Developer who is AI-native from day one — not a traditional engineer who occasionally uses AI, but a builder whose default way of shipping software is through agentic coding tools.
You will architect, build, and operate end-to-end systems with Claude Code as your primary development environment, ship them on AWS + Cloudflare's edge, and own everything from the Vite/React frontend to the Go backend.
This role exists because the way software gets built has fundamentally changed, and we're looking for someone who already lives in that change: who builds and ships complete features in a single Claude Code session, knows how tool calls and agent loops actually work under the hood, writes their own skills and MCPs, and is comfortable composing systems out of edge functions, containers, and small fast services.
If you've ever stayed up too late hacking on your own TUI or Neovim config, you'll fit in here.
Must-Have Skills
- Claude Code
Daily, fluent use of Claude Code as your primary development environment. You should be comfortable with agentic workflows, sub-agents, plan mode, bypass / skip-permissions mode (running with -dangerously-skip-permissions responsibly), slash commands, hooks, and orchestrating long-running multi-step tasks. We expect to see real projects you've shipped with Claude Code — not just chat transcripts.
Codex (OpenAI Codex CLI) experience is preferred; Codex + Claude Code together is a strong plus.
- End-to-End Systems Built with Claude Code
You must be able to take a problem from spec schema backend API frontend deploy entirely through Claude Code, owning the full slice. This means agentic planning, generating and reviewing your own diffs, writing your own tests, and shipping production code without hand-holding. Show us a system you built this way.
- AWS + Cloudflare (Workers + Containers + R2)
- AWS for primary cloud infrastructure — EC2 for compute, EKS / Kubernetes for orchestration, plus supporting services (S3, RDS/Aurora, VPC/networking, IAM).
- Kubernetes.
- Cloudflare Workers for edge compute, request routing, and low-latency APIs.
- Cloudflare Containers for running container workloads alongside Workers with a Worker-based control plane.
- Cloudflare R2 for object storage, plus working knowledge of KV, D1, Queues, and Durable Objects as appropriate.
- Cloudflare for Platforms / Workers for Platforms — building multi-tenant SaaS on top of Workers, dispatch namespaces, isolating customer code, and per-tenant routing. This is core to how our platforms are built.
- Cloudflare for SaaS — custom hostnames, automated SSL/TLS issuance, and per-customer domain onboarding so customers can run on their own branded domains.
- Terraform for infrastructure as code — modules, state management, plan/apply discipline, and provisioning across both AWS and Cloudflare from a single source of truth.
- Comfort wiring AWS services and Cloudflare's edge into a single coherent architecture.
- Vite + React Frontend (Strict DOM)
- Vite as the build tool and dev server — fast HMR, ESM-native dev, Rollup-based production builds.
- React on react-strict-dom — write components against the strict DOM subset so the same code is portable and predictable.
- Modern React patterns: Suspense, transitions, server components where they fit, and careful state management.
- Go Backend
- Idiomatic Go for backend services, APIs, and tooling.
- Comfortable with net/http, context, goroutines, channels, structured logging, and clean module/package layout.
- Building small, fast, container-friendly services that deploy cleanly to AWS and Cloudflare Containers.
- Deep Understanding of the AI Ecosystem and How Tool Calls Work
- You can explain, debug, and design around model tool calls: schemas, validation, retries, streaming, parallel calls, and failure modes.
- You understand how agentic loops actually execute — context windows, tool selection, planning, and the difference between a "chat" and an "agent."
- You can reason about prompt engineering as engineering, not magic.
- Bash Scripting
Confident shell scripting for glue code, automation, dev tooling, CI steps, and quick ops work. You reach for a shell script before reaching for a framework.
- Intermediate-or-Higher Linux and Containerization
- Solid Linux fundamentals: processes, signals, networking, filesystems, permissions, and systemd basics.
- tmux is required. You live in tmux on the company devbox — multiple windows, panes, detached sessions that survive disconnects, and the muscle memory to navigate it without thinking. SSH + tmux is the daily workflow.
- Real containerization experience: Dockerfiles you'd be proud of, multi-stage builds, image hygiene, container runtime behavior, and orchestration concepts.
- Building Skills, MCPs, Slash Commands, and Claude Code Memory
- You've written your own Claude Code skills, MCP servers, and built-in / custom slash commands — not just consumed them.
- You understand the MCP protocol well enough to design clean tool surfaces for agents.
- CLAUDE.md, rules, and memory. You can author and structure CLAUDE.md files, define Claude Code rules, and organize memory at both scopes — user/dev-environment level (~/.claude/CLAUDE.md) and project-by-project (./CLAUDE.md) — so the agent has the right context, conventions, and guardrails for each repo.
- You can extend your own dev environment when off-the-shelf tools don't fit.
- Custom TUI / Dotfiles Culture (Preferred)
A real plus: you have a custom TUI project, a hand-tuned Neovim setup, or similar deeply personalized terminal-first tooling. We're looking for people who care enough about their craft to build the tools they work in.
- Testing, CI/CD, Code Review, and Team Velocity
- End-to-end testing on every push. You must be able to design, write, and run full E2E tests for the code you ship — not just unit tests. Every PR has to be verifiable before review.
- CI/CD fluency. Deep understanding of our CI/CD pipeline (GitHub Actions / GitLab CI). You can read a failing build, debug it, extend pipeline steps, and shepherd a change through every gate without help.
- Bot + human review responsiveness. Every PR goes through multiple automated review bots (Devin, Bugbot, Codex, Copilot, Augment-style review) and human reviewers. You must triage and respond to both efficiently — resolving threads, pushing fixes, asking clarifying questions, and not letting PRs rot.
Must Also Know
Stripe and Stripe Platforms (Connect)
- Working knowledge of Stripe — payments, customers, subscriptions, invoices, webhooks, and idempotency.
- Hands-on with Stripe Platforms / Stripe Connect.
- Comfort designing and shipping payment surfaces that are PCI-conscious, observable, and resilient to webhook replay/duplication.
Additional Strengths
- TypeScript on the frontend — strict-mode TypeScript, well-typed component props, hooks, and API clients. Familiarity is a plus for working with our Vite + React codebase.
- Experience migrating off a Next.js / NestJS / Prisma stack toward a Vite + Go + Cloudflare-edge architecture (we have existing systems that will transition).
- SonarCloud or similar static-analysis discipline — writing code that passes quality gates on first push.
- LangChain, CrewAI, or custom agent pipeline experience.
- Multi-tenant architecture with strict tenant isolation at the code level.
- Distributed / managed SQL at scale — AWS Aurora, CockroachDB, or Google Spanner, and edge-distributed data stores.
- Real-time experience: WebSockets, server-sent events, queues, pub/sub.
- Performance work at scale: caching layers, connection pooling, read replicas, and profiling across the full stack.
