The framework your AI agent already understands
WebJs is a full-stack JavaScript framework with no build step, so nothing is hidden from your agent. The framework ships in node_modules as plain JavaScript it can read end to end, and your app code is served to the browser exactly as written. Any model reasons about the whole stack and debugs it, with no training data required and no single blessed model, on the web components and standard HTML every model already knows.
Nothing is hidden behind a build step
No build step means two things, and both help your agent. The framework itself sits in node_modules as plain JavaScript with JSDoc, so an agent reads it end to end and fits it into context. And your own app code is served to the browser exactly as written, so the agent debugs the running app against the real source, never a bundled or minified artifact.
The framework, readable in node_modules
$ ls node_modules/@webjsdev/core/src
component.js html.js render-client.js
css.js directives.js render-server.js
serialize.js router-client.js
$ grep -rn "renderToString" node_modules/@webjsdev
core/src/render-server.js: export async function renderToString(
server/src/ssr.js: const html = await renderToString(tree)
# plain .js with JSDoc. the agent greps the
# framework source straight from node_modules.Your app code, served to the browser as written
$ curl localhost:5001/components/counter.ts
import { WebComponent } from '@webjsdev/core';
class Counter extends WebComponent({ count: Number }) {
increment() { this.count++; }
}
Counter.register('counter');
# your source, served unbundled. what the
# agent wrote is what the browser fetched.Four reasons the loop just works
Every one of these falls out of a single decision: no build step, on web standards.
What you write is what runs
No build, no bundler, no minifier. Source files are served as native ES modules, so the code your agent reads on disk is byte for byte the code running in the browser. It debugs against reality, never a compiled or source-mapped artifact.
The whole stack is a grep away
The framework ships as plain JavaScript with JSDoc under node_modules. An agent can open @webjsdev/core, follow SSR into @webjsdev/server, and trace a bug end to end without leaving the repo. The answer is always in the working tree.
No training data required
An agent does not need to have seen WebJs before. It fits the framework source into its context window, learns the real API from the code, and starts producing correct output. New model, same result, because the source is the documentation.
Standard HTML and JavaScript
WebJs is built on web components, custom elements, SSR, and forms. Every model, small or large, is already trained on the platform primitives, so the muscle memory transfers instead of fighting a bespoke abstraction.
Experiment with any model, freely
Because the framework itself is the context, you are not locked to the one model that happened to memorize a given API. Point a large model or a small one at a WebJs project and it fits the source into context and gets to work. Switch models between tasks and the output stays reliable, because they are all reading the same readable code.
Human developers get the same deal. There is no hidden compiler output to reverse engineer when something breaks. You open the file, read the JavaScript, and see exactly what ran.
Point your agent at WebJs
Scaffold a full-stack app in one command, then let any model read the source and build. Pages, an API, components, and a database, all on web standards.