Skip to content
MiraiTech
All writing
Dev tools

· 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.

cursor-rules.json
{
  "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.

turbo.json
{
  "$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

MetricBefore TurborepoAfter Turborepo
Average CI build14 min3.2 min
Local full build8 min45 sec (cached)
Monthly CI cost~$480~$120
Package dependency bugsWeeklyRare
New package scaffold time30 min2 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.

biome.json
{
  "$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.

server/routers/project.ts
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.