Newsletter
The Loop: Biome v2: Type-Aware Linting Without the Compiler
By Econify
Wed, Aug 13, 2025

Biome v2: Type-Aware Linting Without the Compiler


Biome v2—codenamed Biotype—marks a major evolution in JavaScript and TypeScript tooling. It introduces type-aware linting that doesn’t require the TypeScript compiler, offering impressive inference capabilities with a smaller performance footprint. In benchmarks, the new noFloatingPromises rule detects 75% of cases that typescript-eslint would catch—without needing typescript installed.


New features include:

  • Multi-file analysis and type inference: Unlocks cross-module linting while keeping scanning opt-in for performance-sensitive workflows.
  • Monorepo-friendly config: Nested biome.json(c) files now supported, with smarter inheritance and no more fragile relative paths.
  • Plugin support: The first version of Biome plugins allows simple rule creation via pattern matching—setting the stage for deeper extension APIs.
  • Revamped Import Organizer: Now merges duplicates, respects grouping, and supports custom sorting strategies—finally organizing imports the way you expect.
  • Assists & suppressions: Non-linting code transformations (like object key sorting) now live under Biome Assist, and new biome-ignore-start/end comments make suppressions more precise.

Biome v2 also ships with an experimental HTML formatter, an early but promising for future support of Svelte, Vue, and Astro. With sponsors like Vercel and Depot backing core features, Biome’s roadmap is ambitious: deeper inference, framework-aware formatting, and markdown support.

Biome is staking its claim as the toolchain of the modern web - faster, more ergonomic, and built for the evolving needs of today’s frontend teams.

Quietly Powerful: Git 2.50 Cleans House and and Streamlines Your Workflow

Git 2.50 quietly delivers a robust set of performance and maintainability upgrades that are particularly impactful for large-scale repositories and automated workflows. While it doesn’t bring headline-grabbing changes, its improvements under the hood make this a critical update for teams looking to optimize reliability and speed across CI/CD pipelines and maintenance tasks.


Critical Upgrades:

  • ORT Merge Engine is now standard: The legacy recursive engine is gone! ORT is faster, cleaner, and now supports quiet, dry-run merging via git merge-tree.
  • Better cruft pack management: New options make it easier to combine and clean unreachable objects without hitting size-based limitations or timestamp bugs.
  • Incremental reachability bitmaps (experimental): Large repos gain support for incremental bitmap indexing via multi-pack indexes, which is great for faster fetches and partial clones.
  • More scripting & automation flexibility: New tools like git-diff-pairs and git update-ref --batch-updates improve parallel processing, bulk updates, and developer tooling.

Swift for Android

Swift is officially coming to Android. The Swift project has launched an Android Workgroup to bring full, native support, starting with proper toolchain integration, CI coverage, and Android-ready builds of Foundation and Dispatch.


It’s still early, but the goal is clear: Swift as a first-class language on Android, with support for sharding, debugging, and even Java interoperability down the line. For teams already using Swift, this opens the door to true cross-platform development without sacrificing native performance. The workgroup is holding meetings every other Wednesday so if this catches your eye, you should check it out.

Vite 7 has arrived

Vite 7 is out with a cleaner, faster core aimed at modern development. It drops support for Node 18, moves fully to ESM-only packages, and updates its default browser target to "baseline-widely-available", aligning better with what users actually run. Legacy features like the old Sass API and splitVendorChunkPlugin have been removed to simplify the ecosystem.


A major highlight is rolldown-vite, a new Rust-based bundler being developed as a faster alternative to Rollup. While not the default yet, it's a glimpse at the performance future Vite is building toward. The team has also announced Vite Devtools, a forthcoming suite for debugging and analyzing builds, developed in collaboration with NuxtLabs.


Upgrading from Vite 6 is straightforward, with minimal breaking changes. For new projects, Vite 7 offers faster cold starts, modern defaults out of the box, and a sharper developer experience - solidifying its position as the go-to tool for modern frontend workflows.

Google’s Linux Terminal

Google is turning Android into a legitimate development platform with its new Linux Terminal app, currently exclusive to Pixel 8+ and select Samsung devices. It runs a full Debian environment in an isolated VM with GPU acceleration, complete with the ability to run desktop Linux apps through a Wayland compositor.


The setup leverages Android's Virtualization Framework (AVF) to spin up a proper Linux instance with hardware-backed security. While it requires developer options and an internet connection for the initial 1.5GB download, what you get is transformative: a real Linux environment that can compile code, run development tools, and even handle GUI applications, all on your phone.

Key capabilities:

  • Full Debian environment: Actual Linux with apt, systemd, and standard GNU tools running in a VM
  • GPU-accelerated graphics: Wayland compositor support means desktop apps run with proper hardware acceleration
  • Persistent storage: Your work survives reboots, with proper file system access between Android and Linux
  • Security isolation: Runs in a protected VM with SELinux policies, keeping your main Android system safe
  • Future ChromeOS integration: Google's roadmap hints at unified terminal experiences across Android tablets and Chromebooks

While currently limited to specific devices and requiring some setup friction, Google's commitment is clear: Android is evolving from a consumption platform to a creation platform. For developers who've wanted a "real computer" in their pocket, that future just got a lot closer.

Every Token Counts: Building Smarter AI Agents with Apollo MCP + GraphQL

Context windows are the new memory limits, and every token counts when designing AI agents. Apollo’s latest blog post dives into how GraphQL + Apollo MCP Server can drastically reduce token usage while improving flexibility, speed, and maintainability of agent tools.


Unlike REST, GraphQL lets agents request only the fields they need—cutting down bloated responses, repetitive schema metadata, and unnecessary tool definitions. Apollo MCP Server builds on this by exposing GraphQL operations as first-class AI tools, eliminating boilerplate and enabling quick iteration without redeploys.

Key takeaways:

  • Tokens are budget, not just cost: Tool metadata, input/output size, and invocation frequency all add up in your agent’s context window.
  • Write less, get more: Use GraphQL to merge/fork operations naturally based on usage, and minimize arguments or hardcode them when possible.
  • Declarative efficiency: Field aliases and operation comments optimize tool descriptions for LLMs without changing schemas.
  • REST? No problem: Use Apollo Router to create a GraphQL layer over existing REST services with zero backend rewrites.

Apollo’s approach puts developers back in control of both the data and the dialogue, enabling longer, more useful conversations with lower latency and cost. As AI agents shift from experimentation to production, this kind of efficiency isn’t just nice; it’s necessary.

Token budgets hit us hard on multi-step agent chains - MCP’s declarative tools look promising, so we’re lining up a proof-of-concept.

CSS Gets Smarter: Inline Conditionals with the if() Function

Chrome 137 introduces a future-facing CSS feature: the if() function, bringing inline conditionals to CSS for style(), media(), and supports() queries. Rather than scattering logic across multiple selectors and @media or @supports blocks, you can now express conditional styles directly on a single property.


This works just like a media query but keeps logic local, readable, and compact. if() also enables more expressive support and style queries. Developers can dynamically apply styles based on custom data attributes or browser capabilities like OKLCH color support, which are all inline and element-scoped.

Highlights:

  • Simpler architecture: Avoid duplication by consolidating logic inside style declarations.
  • Inline media queries: Adjust styles based on pointer type, viewport, or theming preferences without separate rules.
  • Dynamic state styling: Use style() queries with custom props or attributes for UI states (like data-status)—no extra wrappers or JS needed.
  • Forward compatibility: Prepares the ground for future CSS features like range queries and custom @function support.

While experimental for now, if() is shaping up to be a major architectural shift in how we write adaptive, responsive, and state-aware CSS. One to watch.

JSON Imports Hit Baseline: Import JSON Like Any Other Module

JSON imports with import attributes are now baseline across all modern browsers, finally solving one of JavaScript's most annoying gaps. You can now import JSON files directly in ES modules without fetch() gymnastics or embedding data in JavaScript files—just use the standard import syntax with a type attribute.


The syntax is exactly what you'd expect: import data from "./config.json" with { type: "json" }. The JSON is parsed automatically and available as a regular JavaScript object, no JSON.parse() required. This works in browsers, bundlers are catching up, and it's part of the official import attributes spec that also enables future import types like CSS modules.

Technical details:

  • Type safety via attributes: The with { type: "json" } syntax explicitly declares the import type, preventing accidental execution of non-JavaScript files
  • Strict MIME checking: Servers must return proper JSON MIME types (like Content-Type: text/json)—no more treating everything as text/plain
  • Build tool friendly: Works with native ES modules and modern bundlers that support import attributes

The win here is simplicity and security. Configuration files, locale data, and static datasets can now be first-class imports without bundler plugins or runtime parsing. It's also more secure—JSON imports can't execute code, and the explicit type declaration prevents confusion about what's being loaded.

For teams tired of wrapping JSON in JavaScript modules or maintaining separate fetch logic for static data, this is the standardization we've been waiting for. Your build configs just got simpler, and your module graphs just got cleaner.

Stay ahead of the curve with Econify's newsletter, "The Loop." Designed to keep employees, clients, and our valued external audience up to date with the latest developments in software news and innovation, this newsletter is your go-to source for all things cutting-edge in the tech industry.


Missed an issue? Explore The Loop's archive here. New to our newsletter? Subscribe now.


The Loop is written and edited by Victoria LeBel, Alex Kondratiuk, Alex Levine, and Christian Clarke.

Latest Tech Updates in Your Industry

Designed to keep employees, clients, and our valued external audience up to date with the latest developments in software news and innovation. It is your go-to source for all things cutting-edge in the tech industry.

subscribe today

Related Updates

News
We Helped One Client Cut Over $600K in Cloud Spend — Without Sacrificing Performance or Availability
By Econify
Wed, Jul 16, 2025
Newsletter
The Loop: Optimizing for AI and People: The New SEO Playbook from Vercel
By Econify
Thu, Jul 10, 2025
News
Navigating the Pitfalls of Vibe Coding: Observations and Lessons Learned
By Alex Kondratiuk
Thu, Jul 3, 2025
Trusted by top companies
Contact Us
To receive a complimentary analysis of your site’s performance and how it can be improved, reach out.
Address
32 3rd Avenue #128
New York, NY 10003
Reach Out
hello@econify.com
1-833-ECONIFY
Careers
Linkedin
All Rights Reserved © 2024 Copyright Econify • Privacy Policy
Contact Us
Get in touch to discuss your project or development needs.
Address
32 3rd Avenue #128
New York, NY 10003, U.S.A.
5 New Street Square,
London, EC4A 3TW, 

Reach Out
1-833-ECONIFY

© 2025 Copyright Econify • All Rights Reserved • 

Privacy Policy
Careers
Linkedin