Developer Tools · 2024 — Now · In Development
ReCode IDE
A groundbreaking mobile-first IDE rivaling desktop environments with integrated AI agents.
- Role
- Founder & Lead Engineer
- Duration
- Ongoing · since 2024
- Team size
- 4 people
Project overview
What this product is
ReCode IDE is an AI-powered code editor built for phones first — a pocket environment where developers can open a real repository, read and edit code with proper syntax highlighting, run commands, and get AI assistance that actually understands the project context.
It started from a personal habit: most of my best product ideas and worst bug reports arrived away from a desk. Existing mobile options were either toys — a syntax-highlighted textarea — or thin clients that needed a server I had to keep running. ReCode sits in between: a native-feeling editor, a lightweight sync layer, an AI service that knows the repo, and enough terminal to unblock real work.
The product is in active private beta, developed by a small team at Absence Labs.
The problem
Why it existed
Development doesn't stop when you leave the desk, but the tools do. Production incidents, PR reviews and small fixes routinely happen in the exact moments when only a phone is available — and the mobile tooling for those moments is dramatically worse than what developers use at their desks.
Who experienced it
Mobile-first developers, on-call engineers, tech leads reviewing PRs, and indie developers who work in short, scattered sessions.
Why current solutions weren't enough
Existing mobile editors are either text fields with syntax colours, or remote-desktop-style clients that require an always-on host machine. None carry project context, and none have AI that understands the codebase.
The idea
Vision and constraints
Original vision
The original idea was a single sentence: a pocket IDE that respects the craft. Not a viewer, not a toy — an editor where a professional could ship a real fix from a train.
Three principles fell out of that. One: the editor must feel native — 60fps typing, real gestures, no compromise on the fundamentals. Two: AI must be repo-aware and propose, never silently apply — the human stays the author. Three: offline-first — a commute with no signal should still be a productive coding session.
That vision shaped every technical decision that followed, from the virtualized editor surface to the summary-based AI context builder.
Development process
01
Research
Interviewed a dozen developers about their real mobile moments — what they attempted on a phone, what failed, what they stopped trying. 'Review-first' behaviour showed up immediately.
02
Architecture
Two weeks of sketches and spikes: editor core candidates, sync strategy, AI context design. Keeping AI context as summaries, not raw files, unlocked everything else.
03
Development
Built in thin vertical slices: editor and local files first, then sync, then git, then AI. Each slice shipped internally before the next began.
04
Testing
Device-lab testing on mid-range Android and older iPhones; memory profiling; latency instrumentation on typing, search and AI responses.
05
Launch
Private beta via TestFlight and a Play closed track, with in-app feedback capture and a weekly changelog ritual.
My role
Exactly what I worked on
I founded the product and lead its engineering end-to-end — from the first architecture sketch to the beta release, including the AI layer and the deployment pipeline.
Product & Architecture
Defined the vision, scoped the beta, and designed the system: app, sync service, AI service, storage.
Mobile App
Built the React Native app — navigation, gesture system, and the custom editor experience layer on CodeMirror 6.
AI Integration
Designed the repo-aware AI service: context from file summaries, streaming completions over SSE, prompt caching for latency and cost.
Backend & Sync
Node/Express services, WebSocket sync engine, PostgreSQL with Redis for queues and sessions.
Git Integration
Clone, branch, commit, push and PR creation from the phone — credential handling and conflict UX included.
UI/UX & Design System
Thumb-first layout, command palette, and a dark-first design system that survives iOS and Android conventions.
Performance
Set and enforced the budget: keystroke render time, cold start, memory ceilings on mid-range devices.
Deployment
Dockerised services, CI with GitHub Actions, staged rollouts for the beta channel.
Tech stack
The tools that shipped it
Key features
What makes it useful
AI Code Completion
Repo-aware suggestions that stream token by token, assembled from file summaries and recent edits rather than the whole codebase.
- Streaming over SSE with abortable requests
- Diff-first review — the AI proposes, the developer applies
- Prompt cache cuts repeat-context latency dramatically
GitHub Integration
Full read/write git from the phone: clone, branch, commit, push, and open a PR — credentials stored in the platform keychain.
- Branch switcher with lazy worktree loading
- Commit staging with per-hunk selection
- PR creation with generated summaries
File System & Terminal
A virtual file system synced to the cloud workspace, plus a sandboxed command runner for the tasks that unblock you remotely.
- Paged file contents to respect memory budgets
- Sandboxed shell for tests, builds and git plumbing
- Command favourites for one-tap reruns
Cloud Sync
Work continues across devices with an operation-log sync engine and per-file conflict resolution that prefers explicit human choice.
- Operation log instead of whole-file sync
- Offline queue with deterministic replay
- Explicit conflict UI — no silent overwrites
Design & UX
How it feels to use
The design brief was brutal: professional tools, one thumb, half the screen. Every screen was judged against whether a real fix could be shipped one-handed on a bumpy commute.
Thumb-first command bar
The command palette anchors to the bottom third of the screen, so every action is a thumb-reach instead of a stretch.
Reduced chrome
No tab bars or side rails by default. Files, search and git live in gestures and overlays — the code gets the space.
Dark-first, contrast-safe
A dark theme designed for OLED phones and night shifts, with syntax colours tuned for contrast rather than decoration.
Keyboard as layout state
Every screen models the keyboard as a layout participant — editor, palette and terminal reflow with its animation curve.
Technical challenges
And how they were solved
Typing performance on mid-range phones
Syntax highlighting on every keystroke dropped frames badly on mid-range Android. We virtualized the visible lines, batched highlight work between frames, and moved tokenisation off the JS thread where the platform allowed. Keystroke render now sits within a 16ms frame budget on test devices.
AI latency that feels native
Repo-aware completions could take seconds. We assemble context from precomputed file summaries, cache prompts aggressively in Redis, stream tokens over SSE, and make every request abortable — the UI never waits for a response the user has already moved past.
Sync without data loss
Two devices editing offline is a correctness problem, not a feature. The sync engine uses an operation log with deterministic replay and a per-file conflict UI. No silent last-write-wins — users resolve conflicts explicitly, and the engine remembers the preference.
Memory ceilings
A workspace tree, editor state and AI context cannot co-reside in ~200MB. Worktrees load on demand, file contents page, and AI context is summarised — the app holds a hard memory budget with telemetry to prove it.
What I learned
Honest takeaways
ReCode is the hardest thing I've built, and most of the education was about product judgment rather than code.
- Design for what users actually do. We planned for writing features on phones; beta users review and patch. Review-first became the product's centre of gravity.
- AI needs a trust contract. 'The AI proposes, the human applies' converted skeptics faster than any model upgrade.
- Performance budgets are product features. The 16ms typing budget shaped the architecture more than any framework decision.
- Small teams need ruthless slicing. Weekly vertical slices kept four people aligned without meetings.
- Mistake worth admitting: the settings screen shipped late, and its debt touched everything. I'd build it earlier next time.
Results
Outcomes where available
ReCode IDE is in private beta — public metrics don't exist yet. The figures below describe the beta's current shape, with a dash marking targets still being validated.
120+
Private beta testers
Waitlist-backed beta across iOS and Android
40+
Shipped features
Editor, git, terminal, AI and sync surfaces
<16ms
Keystroke render
Within frame budget on mid-range devices
—
Public launch
Targeted once the beta quality bar is met
Final takeaway
Building ReCode IDE taught me…
Building ReCode taught me that the constraint is the product. Designing for a phone made every other decision — the AI contract, the sync model, the performance budget — clearer and better.
Gallery
Editor — syntax highlighting and keyboard-aware layout
AI review sheet — proposed diff with per-hunk apply
Repository browser — lazy worktree, offline badge
Mobile — the one-handed review flow
Keep exploring
