· 6 min read
Tools we kept using in 2024
The tools we picked up in 2024 and still use: Cursor, Turborepo, Biome, Linear and tRPC, plus the ones we tried and dropped.
Tool fatigue
Every year brings a flood of "must-have" developer tools. Most of them solve problems we don't have, or solve real problems in ways that create new ones. We're skeptical by default, but a handful of tools changed how we built software in 2024. These are the ones we were still using after the novelty wore off.
Cursor
We resisted AI-assisted editors for a long time. GitHub Copilot felt like autocomplete with delusions of grandeur: useful for boilerplate, but it interrupted flow more than it helped. Cursor changed our minds.
The difference for us was the interface more than the model. Cursor uses the whole codebase as context, and Cmd+K inline editing ended the copy-paste routine between editor and chat window.
Where it helps
The biggest wins weren't where we expected. Writing new features from scratch got only marginally faster. Refactoring existing code, writing tests for legacy modules and translating between languages went from hours to minutes.
{
"rules": [
"Always use explicit return types on exported functions",
"Prefer const assertions over enum declarations",
"Use drizzle-orm patterns for database queries, never raw SQL strings",
"Error handling must use Result<T, E> pattern from @/lib/result",
"React components must use forwardRef when accepting className prop"
]
}Adoption
We didn't mandate Cursor. Three engineers trialed it for two weeks on a real project and shipped a complex migration in half the estimated time. After that, nobody needed persuading.
Turborepo
We moved to a monorepo in Q1 and regretted it almost immediately. Build times ballooned, CI bills tripled and developers spent more time waiting than coding. Turborepo fixed all three problems.
The remote cache alone justified the switch. Once one engineer builds a package, every later build across the team hits the cache. Average CI time dropped from 14 minutes to 3.
{
"$schema": "https://turbo.build/schema.json",
"globalDependencies": ["**/.env.*local"],
"pipeline": {
"build": {
"dependsOn": ["^build"],
"outputs": [".next/**", "dist/**"],
"cache": true
},
"lint": {
"dependsOn": ["^build"],
"cache": true
},
"test": {
"dependsOn": ["^build"],
"outputs": ["coverage/**"],
"cache": false
},
"dev": {
"dependsOn": ["^build"],
"persistent": true,
"cache": false
}
}
}Before and after
| Metric | Before Turborepo | After Turborepo |
|---|---|---|
| Average CI build | 14 min | 3.2 min |
| Local full build | 8 min | 45 sec (cached) |
| Monthly CI cost | ~$480 | ~$120 |
| Package dependency bugs | Weekly | Rare |
| New package scaffold time | 30 min | 2 min (generator) |
Biome
We dropped ESLint and Prettier in the same week, and it was the scariest change on this list. Both are load-bearing in nearly every JavaScript project. But our ESLint config had grown to 340 lines across 6 files, with 23 plugins and constant version conflicts. Biome replaced all of it with a single binary.
{
"$schema": "https://biomejs.dev/schemas/1.9.0/schema.json",
"organizeImports": { "enabled": true },
"linter": {
"enabled": true,
"rules": {
"recommended": true,
"complexity": {
"noExcessiveCognitiveComplexity": {
"level": "warn",
"options": { "maxAllowedComplexity": 15 }
}
},
"suspicious": {
"noExplicitAny": "error"
},
"style": {
"useConst": "error",
"noNonNullAssertion": "warn"
}
}
},
"formatter": {
"indentStyle": "space",
"indentWidth": 2,
"lineWidth": 100
}
}Biome lints and formats our entire monorepo in under 200ms. The equivalent ESLint + Prettier pass took 18 seconds. At that speed it can run on every keystroke instead of only in CI.
Linear
We switched from Jira to Linear in March, and the migration took a weekend. Every engineer on the team independently said it was the best process change we made all year.
Linear is opinionated and fast. There's no configuration rabbit hole and no Jira Query Language to learn. Cycles, projects and issues are the whole model, and it maps cleanly to how we work.
The GitHub integration
Linear links issues and PRs in both directions. When we merge a PR that references FWD-142, the issue moves to "Done" automatically, so we no longer spend standups reading out status updates.
tRPC
We were already a TypeScript shop, but types stopped at the boundary between client and server. tRPC closed that gap.
export const projectRouter = router({
list: publicProcedure
.input(z.object({
status: z.enum(["active", "archived", "draft"]).optional(),
limit: z.number().min(1).max(50).default(20),
cursor: z.string().uuid().optional(),
}))
.query(async ({ input, ctx }) => {
const projects = await ctx.db.query.projects.findMany({
where: input.status
? eq(schema.projects.status, input.status)
: undefined,
limit: input.limit + 1,
orderBy: [desc(schema.projects.updatedAt)],
...(input.cursor && {
where: lt(schema.projects.id, input.cursor),
}),
});
const hasMore = projects.length > input.limit;
return {
items: projects.slice(0, input.limit),
nextCursor: hasMore ? projects[input.limit - 1].id : null,
};
}),
});The client gets full autocompletion and type checking from this router. Rename a field on the server and the client shows errors immediately. There's no codegen step and no OpenAPI spec to maintain, and runtime validation can't drift from the types.
What we tried and dropped
Not everything stuck:
- Bun as a runtime. Fast, but the Node.js compatibility gaps bit us in production. We still use it as a package manager.
- Playwright for unit tests. Overkill. We kept it for E2E and went back to Vitest for everything else.
- Neon branching for preview deployments. A good idea, but branch databases drifted from the production schema in ways that masked real bugs.
Written by the MiraiTech team in Tokyo
If something here is wrong, or you are working on a similar problem, write to us at contact@mirai-tech.net.