mfsbo

Appearance

2025 felt like the year where two tracks moved fast at the same time:

  • The web platform kept shipping pragmatic, “just use it” features.
  • AI tools stopped being a novelty and started changing day-to-day development workflows.

Early 2025 — AI moved from “chat” to “workflow” ​

The story at the start of the year wasn’t “one model got slightly better”. It was that the shape of using AI inside the editor shifted.

From prompts to repeatable intent ​

Teams moved from ad-hoc “ask the chatbot” usage toward repeatable guidance:

  • Instruction files and structured prompts became a normal part of how you steer tools.
  • “Agent mode” arrived and then quickly became a default way to offload tasks.
  • MCP started showing up as a standardization layer for tools connecting to systems.

The takeaway: the value wasn’t just code generation — it was making work delegatable.

Editing UX changed (tab-driven iteration) ​

A big theme was that the editor UI itself had to evolve. Instead of only completing a single line or snippet, “next edit” style experiences (tab-through changes) became a mainstream workflow. That’s a subtle UX shift, but it’s what made AI feel less like “a separate chat product” and more like “how you edit code now”.

Mid 2025 — Async development became normal ​

One of the most practical workflow patterns is asynchronous work:

  • Draft an issue or task quickly.
  • Assign it to an agent (e.g., Copilot on a PR).
  • Come back later to review, test, and refine.

That changed the “when” of building software. You could move projects forward in small slices without needing a full, focused coding session.

Maintenance work got dramatically cheaper ​

I saw large-scale version migration work (like updating lots of repos/docs for a new .NET release) collapse from days into hours using consistent prompts, reusable instruction files, and reviewable agent output. One of the biggest “quiet wins” of AI-assisted development isn’t flashy greenfield code — it’s keeping projects healthy.

Backend in 2025 — .NET 10 made “API-first” even faster ​

.NET 10 landed this year with a familiar theme: do the same work with less friction and better defaults. The practical impact (for me) was that spinning up an API and getting it to production-grade patterns felt faster — not because any single feature was magic, but because the ecosystem keeps compressing the path from idea → running service.

A few things that stood out:

  • The “start small, grow safely” story continued: minimal APIs are an even more normal default for new services, and it’s easier to layer on validation, auth, and observability without rewriting your app shape.
  • Performance work is relentless: runtime + libraries keep improving the baseline so you get wins simply by moving forward.
  • Cloud-native .NET felt more cohesive: .NET Aspire continued to make local dev environments (services + dependencies) easier to model, run, and reason about.

If you’re building backends today, the biggest advantage is momentum: modern templates, stronger defaults, and a better set of primitives for building “boring” APIs that are fast, secure, and easy to operate.

Infra + security — GitHub quality and review workflows matured ​

This was also a year where backend infrastructure and security felt meaningfully better just from disciplined GitHub hygiene.

The big shift wasn’t a new tool — it was treating quality gates as part of delivery:

  • PR review workflows that are consistent (ownership, required reviewers, clear merge strategy).
  • Automated checks that actually matter (tests, linting, formatting, policy checks).
  • Security features that reduce risk by default (code scanning, secret scanning, dependency alerts, Dependabot updates).

When that baseline is in place, you spend less time “detecting surprises” and more time shipping intentionally.

Throughout 2025 — The model landscape exploded ​

I think of 2025 as “a year of models”:

  • Google’s Gemini line (noted as a meaningful step up).
  • Anthropic’s Claude line (frequently treated as a top-tier coding model).
  • OpenAI’s rapid iteration with many variants.
  • A more global landscape (e.g., DeepSeek mentioned as a strong entrant).
  • Open source models becoming more capable and more specialized.

The practical outcome: picking “the model” became less important than knowing which model fits which task (speed vs reasoning vs coding vs cost).

Frontend in 2025 — frameworks kept getting faster and cleaner ​

On the frontend side, the story wasn’t “one framework won” — it was that Vue, React, and Svelte all kept shipping upgrades that improve performance and developer ergonomics.

  • Vue continued to refine the Vue 3-era baseline: better performance characteristics, smoother tooling, and stronger patterns for large apps.
  • React kept pushing modern rendering and app architecture patterns, with continued emphasis on performance and predictability.
  • Svelte’s evolution (including the newer compiler/model direction) kept leaning into “less runtime, more compile-time”, which tends to translate into very direct performance wins.

In practice, the biggest UI performance improvements still come from fundamentals (shipping less JS, controlling rendering work, measuring real user performance), but the framework/tooling upgrades make it easier to stay on the happy path.

TypeScript in 2025 — quality-of-life and scale improvements ​

TypeScript kept improving the “large codebase experience”: faster iteration loops, better type-system ergonomics, and steady enhancements that reduce friction when you’re working across many packages or repos.

The big win is cumulative: when types + tooling are fast and reliable, you get more refactors, fewer regressions, and a stronger shared language between frontend and backend.

Developer experience — Google and editors moved closer to AI-assisted building ​

The development experience changed not just inside editors, but across the broader ecosystem. Google’s developer tooling story also moved in the “AI is part of the workflow” direction — which is less about replacing expertise and more about making exploration, debugging, and documentation lookup feel immediate.

I’m intentionally treating this as a long-term shift: AI is becoming an interface layer on top of docs, build systems, and debug tooling.

Late 2025 — The web platform got a Baseline boost ​

Web features reached a point where you can use them broadly (progressive enhancement still applies, but the floor is higher).

UI and interaction primitives became more native ​

These features reduce the need for heavy JS/portal hacks and make common UI patterns feel more like first-class platform capabilities:

  • Same-document view transitions for smoother SPA-style transitions.
  • The Popover API for lightweight overlays that sit in the top layer.
  • A continued theme of building UI declaratively with better browser primitives.

CSS kept leveling up as a “real programming surface” ​

The direction CSS has been heading:

  • More expressive math (e.g., an absolute value function) to simplify complex layout/animation calculations.
  • Better animation ergonomics when elements enter/leave or change discrete properties (where supported).

The vibe: less “CSS can’t do that” and more “try CSS first, then JS”.

JavaScript/platform ergonomics improved ​

Several Baseline items were about making common tasks cleaner without bundler magic:

  • JSON modules — importing JSON directly in ESM without hacks.
  • Promise.try — making it easier to unify sync and async flows.

Performance and rendering controls became more usable ​

Content visibility stood out as a tool you can apply surgically to reduce offscreen rendering costs, with the caution that it needs testing to avoid unintended layout shifts.

Encoding / binary data handling got less awkward ​

Also want to touch on moving away from older base64 string patterns toward typed-array based approaches that can be friendlier to DOM/perf usage patterns. Also want to touch on moving away from older base64 string patterns toward typed-array based approaches that can be friendlier to DOM/perf usage patterns.

A 2025 pattern worth calling out — Progressive enhancement is back ​

I keep coming back to the same practical stance:

  • Use modern features when they’re broadly available.
  • Design so older browsers get a functional experience (maybe without the animation/perf win), instead of breaking.

This mindset maps well to Baseline-style feature rollouts and also to AI tooling adoption: keep your “human in the loop” and your fallback paths.

Things I “vibe coded” this year (and what I learned) ​

I also leaned into building small, high-leverage internal tools — the kind of apps you don’t overthink, but that quietly remove friction.

  • A DORA metrics helper that pulls signals across multiple repositories, where delivery is split between frontend (Vue) and backend (API) work. The takeaway: a small amount of consistent metadata + automation can make delivery conversations far more objective.
  • A Vue + Tailwind meeting room tool to import/export attendees and run Scrum events (daily standup, retrospectives, planning). The takeaway: lightweight UX and fast iteration beats “perfect process” tooling.
  • Automation around GitHub Actions to support legacy infrastructure, which let me upgrade roughly a quarter of a million releases this year — about a 10× throughput improvement with dramatically fewer errors (on the order of ~50× fewer). The takeaway: reliability is usually a workflow problem before it’s a code problem.

These projects reinforced a simple idea: the best tools aren’t the biggest — they’re the ones that remove a repeating annoyance.

AI outside of coding — it became normal for everyone ​

One of the most interesting changes in 2025 is how quickly AI became useful to non-developers too.

I helped a few people use AI for:

  • brainstorming and structuring book ideas,
  • iterating on cooking recipes,
  • and (importantly) understanding the limitations of LLMs: when they’re helpful, when they hallucinate, and how to verify.

That last point matters: the real skill isn’t “using AI” — it’s knowing how to validate and integrate it responsibly.

What I’m carrying into 2026 ​

The priorities that feel durable:

  • Frontend: lean harder on platform primitives (popover/top-layer patterns, view transitions where appropriate, progressively enhanced CSS-driven UX).
  • Tooling: treat agent workflows as a first-class part of delivery (especially for maintenance, migrations, and review prep).
  • AI in apps: experiment more with local/on-device models where privacy, latency, and cost are central.

Learning resources (worth bookmarking) ​

If you want to go deeper on any of the threads above:

A quick look at 2026 ​

Going into 2026, I’m optimistic about the opportunities for parents, developers, and DevOps folks across small businesses and enterprises: AI-assisted workflows reduce the “time tax” of context switching, better platform primitives keep simplifying frontend and backend work, and automation makes mature systems easier to operate. My focus is to use that leverage responsibly — ship smaller, ship more often, and keep reliability and security as defaults rather than afterthoughts.

Random thoughts on Tech

Copyright © mfsbo v1.0.1 (9d3de1a) Tue, 27 Jan 2026 02:44:27 GMT