AI Breaks Developer Boundaries 1 - Why Walls Form

Series · AI Breaks Developer Boundaries

Article series · Ongoing

Episode 1 · AI Breaks Developer Boundaries 1 - Why Walls Form

This is the first of a three-part series on the boundaries among web, game, and embedded development, and on how AI tools are reshaping them. A developer has long been someone who absorbs the cost of connecting layers that were not designed to fit together neatly.

After enough time in one kind of project, other disciplines can feel foreign. A web developer may hesitate at a game server's threading model; a game developer may slow down when a board and a serial port appear; an embedded engineer may regard browser-framework churn as someone else's weather. That is not a measure of intelligence. Each domain has required a different shape of knowledge.

This article describes those differences without romanticizing them. The later articles will not argue that AI automatically performs every technical task. They ask a narrower question: how does AI lower the cost of searching, translating, and experimenting when someone first crosses an unfamiliar boundary?

Here, enterprise web development includes public-sector, finance, and business systems. The list of technologies below does not mean one person uses every item in every project; it shows why the combinations can become difficult.

Web complexity comes from combinations more than a single depth

The web looks approachable because anyone can render HTML, style it with CSS, and add behavior with JavaScript. Production work, however, also joins HTTP, identity, databases, deployment, accessibility, browser compatibility, logging, security patches, and incidents. MDN distinguishes browser APIs, third-party APIs, and libraries or frameworks in its client-side API introduction. The joins between those layers are the real boundary.

It helps to keep languages and tools in separate categories. HTML, CSS, JavaScript, TypeScript, and SQL express structure, presentation, behavior, types, or queries. Java, C#, and PHP can serve the backend. XML and JSON are data formats; JSP is a Java-based server-page technology. Spring and Spring Boot are server frameworks; React, Vue, Angular, and Svelte are client UI ecosystems; Node.js is a runtime; Vite is a build tool; Electron is a desktop runtime. MySQL, Oracle, SQL Server, and PostgreSQL are DBMS products with different operational trade-offs. CSS has also advanced through modules and browser support, not as one monolithic “CSS5.”

So even a small-looking feature often contains multiple contracts:

type Profile = { id: string; displayName: string };

export async function loadProfile(signal: AbortSignal): Promise<Profile> {
  const response = await fetch('/api/me', {
    headers: { Accept: 'application/json' }, credentials: 'include', signal,
  });
  if (!response.ok) throw new Error(`profile request failed: ${response.status}`);
  return response.json() as Promise<Profile>;
}

Behind this function sit session policy, CORS, API versioning, schema design, observability, and privacy decisions. Web developers built broad experience not because they merely skimmed technologies, but because they repeatedly owned a new combination of those decisions. The AI coding era can propose combinations faster, but product and organizational context still chooses among them.

<The connection points that create different boundaries across development domains 1.1>

Games move code and assets together

Reducing game development to “knowing C++” misses half the product. C++ remains widely used in performance-sensitive engine, network, and tooling work, while C# and other stacks coexist. More importantly, a game is not code alone: scenes, GameObjects, Components, Prefabs, textures, materials, 3D models, animation, and sound refer to one another. Unity's key concepts describe those building blocks, and its Inspector documentation shows how components and exposed fields can be adjusted without editing source.

using UnityEngine;
public sealed class FollowTarget : MonoBehaviour {
  [SerializeField] private Transform target;
  [SerializeField] private float speed = 4f;
  void Update() {
    if (target == null) return;
    transform.position = Vector3.MoveTowards(transform.position, target.position,
      speed * Time.deltaTime);
  }
}

The code is ordinary, but target needs a scene object or Prefab and speed needs a design decision. Source code alone may not reconstruct which Prefab was connected, what import configuration and material produced the image, or what felt wrong in play. Unity's asset workflow explains how asset identifiers and references are preserved. The accurate statement is not that AI cannot learn editor work; it is that assets, visual evaluation, and runtime context make text-only reconstruction incomplete.

Unreal teaches the same lesson. Epic's Blueprint versus C++ guide says most projects benefit from combining both. Blueprint helps asset and API discovery; C++ helps with text diffs, merges, and low-level control. Shaders, animation, and effects cross tools such as Materials, Niagara, and Sequencer, as well as an art pipeline. The boundary is therefore a production-pipeline boundary as much as a language boundary.

Embedded systems add the physical world

In embedded development, correct code can still produce a failed product. Board power, pin layout, voltage, firmware version, sensor noise, serial speed, and boot order all participate. Diagnosing a problem may require cables, instruments, boards, and firmware revisions in addition to a log. A Linux-based board adds an OS, device trees, drivers, permissions, and a filesystem. A web UI talking to the device may need a local service or native bridge.

Before writing a serial driver, a developer may first inspect what is connected:

ls /dev/ttyUSB* /dev/ttyACM* 2>/dev/null
sudo dmesg --ctime | tail -n 40
stty -F /dev/ttyUSB0 115200 cs8 -cstopb -parenb

These commands do not control a device or flash firmware; they merely inspect connectivity and configure a known test port. Chip vendor, board design, OS, and Bluetooth stack can change the debugging path completely. That is why embedded expertise is more than C/C++ syntax.

A boundary is the cost of verification, not a lack of intelligence

Domain	Central complexity	Evidence outside code	How failure is verified
Enterprise web	Many layers and requirements combined	policy, browser, data	tests, logs, user journeys
Games	Real-time performance and asset pipeline	scenes, Prefabs, art, play feel	profiling and play tests
Embedded	OS and hardware together	board, power, sensors, firmware	instrumentation, logs, physical tests

<How verification cost accumulates differently in each domain 1.2>

Parallelism in games is a useful example. More threads can relieve a bottleneck, but they can also introduce races and hard-to-reproduce bugs. Unreal's performance considerations explicitly warns about threads and race conditions. The solution is profiling and measurement, not a language-level guess.

AI may lower the boundary, but it does not erase responsibility. Game frame time, web privacy, and embedded electrical or mechanical safety require real measurements and approval processes, not generated code alone.

Developers built value in their domain not merely by keeping secrets. They linked documentation, failed logs, tools, and site constraints until a system was verified. The next article examines why AI can draw that initial map faster, and why public code plus code-native interfaces matter. A familiar developer CLI workflow can become an experiment interface when combined with AI.

Previous episodes

No previous episodes have been published yet.

View the first episode