How AI transforms Engineering roles

Vlad — Sun, 01 Mar 2026 03:58:33 +0000

It’s crazy how quickly I stopped coding. AI (LLMs, whatever you want to call it) does it for me now. In just a matter of weeks, my attitude toward coding changed dramatically — and I don’t think I’ll ever go back.

I’ve been doing front-end development for more than 8 years. Now I truly believe that coding itself doesn’t matter that much anymore. The art of programming used to lie in creating elegant and efficient patterns and architectures that allowed systems to be developed quickly without significant losses in performance or maintainability. A good programmer could design a system in such a way that adding new functionality was relatively simple and fast.

Now manual coding no longer makes much sense, because LLMs can process massive codebases in minutes. So how does the role of engineers change under these conditions? “Programmers are no longer needed! The profession is disappearing!” — I would call these loud but empty statements. In my view, the profession is transforming. A programmer’s job is no longer to write code, but to manage its creation. Let machines handle the coding. What remains for humans?

We design systems and applications to solve practical problems, so from a business perspective it’s crucial to clearly define the problems that need solving and then deliver a product that addresses them as quickly as possible. Problem-solving is now a critically important skill, and engineers especially need to understand how to design products that meet business requirements. This means that understanding fundamental architectural principles and choosing the right tools to build that architecture become essential developer skills. In other words, engineers should define the direction and design approach of the system, while LLMs handle implementation.

The engineer now moves beyond the purely technical domain. They partially become an architect of the product itself, which makes product sense a critically important skill as well. Increasingly, the engineer’s role shifts toward that of a product owner. To build technically effective solutions, you must understand the problems the solutions are meant to address — both technical and user-related — that may arise during development.

AI also provides many opportunities and suggestions (sometimes too many) for creating new products, but they shouldn’t always be followed. Now we can implement complex functionality with the click of a button, which creates the temptation to build everything at once. It’s important to understand that not everything needs to be built. Instead, we must carefully define necessary functionality and priorities, so planning and understanding what truly delivers value become central skills.

Ultimately, an engineer’s role is no longer to write code, but to orchestrate it — reducing product iteration time and creating a reliable technical foundation for future product decisions. This is a new level, and many people will have to adapt.

LLMs are not only transforming the profession itself, but also the way people enter it. How beginners will acquire the necessary knowledge in this new environment remains an open question — and I look toward the future with great interest.

Fully customizable bun server for Astro

Vlad — Sun, 29 Jun 2025 03:04:09 +0000

I want to use bun with astro, but there're outdated adapters. In this article I'll show you how easy you can setup SSR of astro project with bun with full control on your server.

Custom adapter

Why don't we just build our own adapter? Some might think that it's a difficult task, but I'll show you that it's very simple and straightforward.

Firstly have a look at docs.

Let's make "adapter.ts"

import type { AstroAdapter, AstroIntegration } from "astro";
import path from "path";

export function getAdapter(...args: unknown[]): AstroAdapter {
  return {
    args,
    // from Astro we only need manifest file and that's it.
    exports: ["manifest"],
    // Custom name for our adapter
    name: "bun-custom-adapter",
    // Here's the name of the file with server entrypoint
    // See the details below
    serverEntrypoint: path.join(import.meta.dirname, "bun-adapter.js"),
    // Here you can set supported astro features
    supportedAstroFeatures: {
      envGetSecret: "unsupported",
      hybridOutput: "unsupported",
      i18nDomains: "unsupported",
      serverOutput: "stable",
      sharpImageService: "stable",
      staticOutput: "stable",
    },
  };
}

export function astroBunAdapter(): AstroIntegration {
  return {
    name: "bun-custom-adapter",
    hooks: {
      "astro:config:done": (params) => {
        params.setAdapter(
          getAdapter({
            assets: params.config.build.assets,
            client: params.config.build.client?.toString(),
            host: params.config.server.host,
            port: params.config.server.port,
            server: params.config.build.server?.toString(),
          }),
        );
      },
    },
  };
}

Now we need to create bun-adapter.ts. The only thing it will export is manifest with static files:

import type { SSRManifest } from "astro";

// All we need from astro-adapter is ssr manifest
// Adapter is ready!
export function createExports(manifest: SSRManifest): {
  manifest: SSRManifest;
} {
  return { manifest };
}

That's it, you're done! But wait, what's next? How to work with this?

Server setup

I want to have a full control on my server, that's why I'll use hono with bun (but you can use any server framework that you like - even bare bun).

import { App } from "astro/app";
import Bun from "bun";
import { Hono } from "hono";
import { serveStatic } from "hono/bun";

// Import our built manifest
import { manifest } from "./dist/server/entry.mjs";

// create apps
const app = new Hono();
const astroApp = new App(manifest);

// Serve static files from _astro folder
app.get(
  "/_astro/*",
  serveStatic({
    precompressed: true,
    root: "./dist/client",
    onFound(_, context) {
      // Here you can customize headers and do whatever you want
      // I just added caching headers for static files
      context.res.headers.set("Cache-Control", "public, max-age=31536000, immutable");
    },
  }),
);

// Here we serve files from /public folder (they're just copied)
app.get("/:filename{.+\\.(png|ico|txt)}", serveStatic({ root: "./dist/client" }));

// Here we render astro app
// If you use API routes, you may also want to allow other methods
app.on(["GET"], "*", (context) => {
  const routeData = astroApp.match(context.req.raw);

  if (!routeData) return new Response("Not Found", { status: 404 });

  return astroApp.render(context.request.raw, {
    addCookieHeader: true,
    routeData,
    // you can also pass client address here from
    // request headers if you need it
  });
});

// run our server
const server = Bun.serve({
  hostname: YOUR_HOST,
  port: YOUR_PORT,
  fetch: app.fetch,
});

const exit = () => server.stop();

process.once("SIGINT", exit);
process.once("SIGTERM", exit);
process.once("exit", exit);

That's it! With this minimum code you get full control over your server. You can easily add anything you want. Of course, if you want to have everything working out of the box, I recommend you using node adapter with express.

DEV Community: Vlad

How AI transforms Engineering roles

Fully customizable bun server for Astro

Custom adapter

Server setup