# Show HN: WebCraft Pro – CI-enforced engineering standards for AI coding agents

> Source: <https://github.com/ViviBeri/webcraft-pro>
> Published: 2026-11-18 17:31:31+00:00

**Key takeaway:** WebCraft Pro packages 43 portable SKILL.md files and CI workflows that scan Markdown code examples for eval(), new Function(), unsafe innerHTML, document.write(), unsafe href values and wildcard postMessage() origins, and run Playwright keyboard/focus tests in Chromium.

**Design with intention. Engineer with discipline. Secure by default.**

WebCraft Pro is an open-source, framework-agnostic collection of **43 reusable Agent Skills**, shared engineering standards, practical examples, and verification workflows for building distinctive, accessible, performant, and secure web applications.

It provides AI coding agents with a structured engineering process covering the complete website delivery lifecycle—from initial design direction through implementation, accessibility, security, performance, browser QA, and release.

WebCraft Pro organizes the engineering lifecycle into eight stages:

| Stage | Area | Purpose | 
|---|---|---|
| 01 | Foundation and Agent Interoperability | Establish repository conventions, portable skills, installation, and shared agent instructions. | 
| 02 | Design Intelligence | Define visual direction, design systems, hierarchy, and product-specific interfaces. | 
| 03 | Frontend Engineering | Build maintainable components, responsive layouts, forms, and frontend architecture. | 
| 04 | Motion and GSAP | Create purposeful animation, scroll experiences, and accessible motion systems. | 
| 05 | Accessibility Engineering | Apply semantic HTML, keyboard navigation, screen-reader testing, and WCAG-oriented reviews. | 
| 06 | Web and API Security | Address authentication, authorization, input handling, API risks, secrets, and security testing. | 
| 07 | Performance Engineering | Measure and improve Core Web Vitals, rendering, JavaScript, images, fonts, and network delivery. | 
| 08 | Browser Automation, QA and Release | Verify rendered experiences, browser behavior, accessibility checks, screenshots, and release readiness. | 

The stage directories provide the roadmap, acceptance criteria, and supporting documentation. Canonical skills remain in `skills/`, avoiding duplicated skill instructions across stages and AI agents.

WebCraft Pro includes complementary GitHub Actions workflows and browser verification tooling.

The `Validate Repository` workflow checks:

- Skill metadata and required frontmatter.
- Skill directory and naming consistency.
- Eight-stage repository structure.
- Skill validator tests.
- Installer tests.

The `Security Pattern Audit` workflow runs a Node.js static pattern scanner built using Node.js standard-library modules.

It scans Markdown code fences in:

- `skills/`
- `standards/`
- `examples/`

It checks for patterns including `eval()`, `new Function()`, unsafe `innerHTML` assignments, `document.write()`, potentially unsafe `href` values, and wildcard `postMessage()` origins.

The workflow tests the scanner, generates a JSON report, verifies the report, and uploads it as an artifact.

**Scope limitation:** This is a static Markdown code-example pattern audit—not a complete application security scanner or proof of security.

The `Accessibility Keyboard Tests` workflow installs Chromium and executes the Playwright keyboard/focus test suite.

The current tests cover:

- Skip-link keyboard access and focus visibility.
- Form validation errors and focus management.
- Dialog focus entry, Escape-key dismissal, and focus restoration.

The repository also includes an on-demand browser checker using Playwright and axe-core.

It supports:

- Chromium browser verification.
- Mobile, tablet, and desktop viewport profiles.
- Standard and reduced-motion modes.
- Keyboard tab-order and visible-focus checks.
- axe-core accessibility scans.
- JavaScript error detection.
- Screenshots and JSON reporting.

This checker is available through the Manual Browser Check workflow. It is separate from the push-triggered keyboard-test workflow.

Automated checks complement—not replace—manual assistive-technology testing, security review, cross-browser verification, and real-user performance measurement.

The canonical `skills/` directory contains 43 portable `SKILL.md` files covering:

- Design intelligence and visual quality.
- Frontend architecture, component engineering, and document head, SEO, and meta tags.
- Responsive design and modern CSS.
- GSAP, motion systems, and interactive storytelling.
- Accessibility, WCAG auditing, keyboard focus, and screen readers.
- Application security, authentication, authorization, and API security.
- Core Web Vitals, rendering, JavaScript, images, fonts, and network performance.

Skills follow the Agent Skills format and are organized by task rather than tied to one frontend framework.

The repository includes 13 practical templates across the three engineering-critical domains:

**Accessibility — 5 templates**

- Accessibility audit plan.
- Semantic review checklist.
- Screen-reader test matrix.
- Accessibility audit report.
- Accessibility finding template.

**Security — 3 templates**

- OWASP control mapping, including illustrative ASVS 5.0.0 and API Security Top 10 mappings.
- Security verification matrix.
- Security review report.

**Performance — 5 templates**

- Performance audit template.
- Core Web Vitals record.
- Performance test matrix.
- Performance investigation template.
- Performance budget template.

These templates help agents and engineers record scope, test conditions, evidence, findings, remediation, and release decisions consistently.

WebCraft Pro is engineered as a repeatable web-delivery system, not just a collection of prompts or a wrapper around a preferred frontend stack.

**Enforced by CI, not just Prompts:** While other repos provide massive text prompts hoping the LLM follows them, WebCraft Pro turns engineering guidance into verifiable CI checks. It combines repository validation, a zero-dependency security pattern audit, and Playwright keyboard/focus tests. These checks make defined engineering requirements measurable and enforceable in CI, while keeping their scope explicit.

WebCraft Pro does not lock projects into a proprietary animation engine or require a heavy UI library to adopt its engineering approach. It provides portable skills, shared standards and verification workflows; teams bring their existing framework and choose implementation dependencies only when the project needs them.

Use GSAP where coordinated motion justifies it, native CSS for simpler effects, and the framework already present in the project. Optional libraries remain optional.

Single-purpose skills can be valuable for a focused task, but WebCraft Pro organizes the broader delivery pipeline into eight connected stages: foundation and agent interoperability, design intelligence, frontend engineering, motion and GSAP, accessibility, web and API security, performance, and browser QA and release.

That architecture connects design direction and implementation with OWASP-informed security work, accessibility verification, performance measurement and release readiness. Shared standards, templates and CI workflows provide continuity across those stages instead of leaving each task as an isolated prompt.

WebCraft Pro is designed to be a reusable engineering reference, not a collection of instructions to blindly apply to every project.

Recommended agent workflow:

1. **Understand the repository.** Read`README.md` ,`AGENTS.md` , and`stages/README.md` to understand the project conventions and eight-stage architecture.
2. **Identify the task.** Select the relevant skill from`skills/README.md` and read its complete`SKILL.md` .
3. **Read the engineering standard.** Consult the relevant document in`standards/` before making domain-specific decisions.
4. **Use the supporting template.** Select an appropriate audit, test matrix, finding, investigation, or report template from`examples/` .
5. **Inspect the actual application.** Adapt guidance to the existing framework, architecture, user journeys, and constraints.
6. **Implement and verify.** Use appropriate tests, browser checks, accessibility reviews, and security or performance evidence.
7. **Report honestly.** Document what changed, what was tested, what passed, remaining risks, and checks that were not performed.

The installer supports three agent environments:

| Agent | Project-local destination | 
|---|---|
| OpenAI Codex | `.agents/skills/` | 
| Claude Code | `.claude/skills/` | 
| GitHub Copilot | `.github/skills/` | 

Preview installation:

```
node scripts/install-skills.mjs --agent all --target /path/to/project --dry-run
```

Install all skills:

```
node scripts/install-skills.mjs --agent all --target /path/to/project
```

Use `--agent codex`, `--agent claude`, or `--agent copilot` to install for an individual agent. Existing skill directories are protected from accidental overwrites unless `--overwrite` is explicitly supplied.

WebCraft Pro maintains shared standards for:

- Design quality.
- Frontend engineering.
- Motion engineering.
- Accessibility engineering.
- Security engineering.
- Performance engineering.

Its core principles are:

- Prefer deliberate, product-specific design over generic interfaces.
- Preserve maintainable architecture and existing project conventions.
- Use semantic HTML and accessible interaction patterns.
- Treat security as an engineering requirement, not a final checklist.
- Measure performance using reproducible evidence.
- Use automation where it adds confidence, while documenting its limitations.
- Keep reusable skills framework-agnostic unless a skill explicitly targets a technology.
- Never claim verification, conformance, or security without supporting evidence.

The eight-stage architecture, 43 canonical skills, shared standards, and 13 Stage 5–7 engineering templates are maintained in the repository.

The latest commit is:

`bcc99b078a8f956729c4b2276b921136bf3acf2e`

The following workflows were verified green on that commit:

- Validate Repository.
- Security Pattern Audit.
- Accessibility Keyboard Tests.

WebCraft Pro provides a complete structured foundation for AI-assisted web engineering. Individual applications still require project-specific implementation, testing, and human review before release.

**WebCraft Pro — Better interfaces. Better engineering. Safer releases.**

This project is licensed under the MIT License - see the [LICENSE](https://github.com/ViviBeri/webcraft-pro/blob/main/LICENSE) file for details.

Third-party development dependency licenses are listed in [THIRD_PARTY_LICENSES.txt](https://github.com/ViviBeri/webcraft-pro/blob/main/THIRD_PARTY_LICENSES.txt).
