Harness AI Engineering Programming: A Practical Guide to the Rules + Skills + Wiki + Changes Four-Layer System

The Reality of AI Programming: Why 90% of People Can't Use AI to Write Code Effectively

The current AI programming landscape presents a fascinating polarization: on one hand, top tech companies like Anthropic and OpenAI have AI completing over 90% of their code writing; on the other hand, a large number of developers have retreated back to "traditional programming"—the old way of writing code entirely by hand—after trying AI programming.

Where does the problem lie? The answer is quite clear: Most people only know how to use AI for simple projects but have no idea how to harness AI for real enterprise-level development.

This article is based on insights shared by a technical expert with architect-level experience at major companies like JD.com and Vipshop. It systematically introduces how to use the Harness AI Engineering Programming methodology to build a Rules + Skills + Wiki + Changes four-layer architecture with Claude Code, enabling automated and controllable development of enterprise-level projects.

Three Typical Modes of Current AI Programming

Based on real-world research, developers currently use AI programming in roughly three categories, each with vastly different efficiency levels and ceilings.

Type One: Fragmented Use — Treating AI as a Glorified Search Engine

Developers toss a small feature, module, or page requirement to an AI model, or even generate code through web-based tools like Doubao, then manually paste it back into their IDE. This approach essentially treats AI as a "glorified search engine," offers very limited efficiency gains, and cannot handle complex projects.

Type Two: Tool-Assisted — Progress but Lacking a System

Using integrated development tools like GitHub Copilot, Claude Code, or Cursor to get real-time AI assistance during coding. This approach is a step up from the first type, but still lacks systematic engineering thinking and easily spirals out of control when facing complex business scenarios.

Technical Positioning of Claude Code: Claude Code is a command-line AI programming tool for developers released by Anthropic. Its core difference from tools like Cursor and GitHub Copilot lies in its "Agentic" working mode. It can not only generate code snippets but also proactively read the file system, execute terminal commands, invoke external tools, and maintain contextual coherence across multi-step tasks. This architecture makes it particularly suitable for integration with external knowledge systems like Rules/Wiki, because it can proactively retrieve and reference these constraint files before generating code, rather than relying on the context window of a single conversation.

Type Three: Engineering System — The Right Way to Harness AI Programming

This is what this article focuses on — Harness AI Engineering Programming — establishing a complete rule system and knowledge architecture to have AI complete complex enterprise-level project development under strict constraints. This is currently a proven method that truly unleashes AI programming productivity.

Where Exactly Is the Ceiling for Beginner AI Programming?

Recently, social media is flooded with claims like "product managers building complete projects from scratch with AI" and "zero-experience developers creating amazing products with Claude Code," causing anxiety among many professional developers. But upon calm analysis, you'll notice these cases have obvious limitations:

Projects that can be done: Simple web pages, small demos, single-function products — simple business logic, low technical requirements.

Projects that can't be done: Enterprise-level ERP systems, microservice distributed architectures, high-concurrency internet platforms — high business complexity, deep tech stacks, strong system coupling.

The Complexity of Microservices and Distributed Architecture: Microservice architecture splits monolithic applications into multiple independently deployed small services, each built around a specific business capability. While this architecture improves scalability and team autonomy, it also introduces complexities inherent to distributed systems: network latency and fault handling in inter-service communication, consistency guarantees for distributed transactions (CAP theorem trade-offs), service discovery and load balancing, distributed tracing and observability, etc. These issues require deep technical expertise to handle correctly, and this is precisely the ceiling that "beginner AI programming" cannot reach. Without explicit constraints, AI often generates code that runs fine in a single-machine environment but harbors race conditions or data inconsistency risks in distributed scenarios.

The core issue is this: when an unsolvable bug is encountered during AI programming, a person without technical expertise can interact with the model for dozens of rounds and still fail to resolve it — the project gets permanently stuck. A professional developer, on the other hand, can intervene and fix things even when hitting AI's limitations.

This precisely demonstrates that AI programming isn't about replacing developers, but rather requires developers to master a new set of engineering methods to harness AI.

What Is Harness Engineering?

"Harness" translates to "驾驭" (to control/master) in Chinese, and the core philosophy of Harness Engineering is: Control AI models like reining a horse, keeping them working efficiently on a controllable track.

Why Enterprise-Level AI Programming Must Adopt Harness Engineering

In real-world AI programming, developers commonly face four major pain points:

• Hallucination problems: AI-generated code looks reasonable but contains logical errors or calls non-existent APIs
• Inconsistent code standards: AI-generated code style clashes with the existing project codebase
• Context loss: As conversation rounds increase, AI gradually "forgets" the project's overall architecture and constraints
• Quality degradation: After prolonged interaction, code quality noticeably declines, with repetitive, redundant, or even contradictory implementations

Technical Root Cause of AI Hallucinations: The "Hallucination" problem in large models stems from their underlying generation mechanism. Current mainstream Large Language Models (LLMs) are essentially probability prediction systems based on the Transformer architecture, generating content by predicting "the next most likely Token" rather than truly "understanding" code logic. This means that when generating code, the model may confidently call APIs that don't exist, reference incorrect function signatures, or generate implementations that are syntactically correct but logically wrong. In programming scenarios, hallucination problems are particularly dangerous because erroneous code often compiles successfully but causes hard-to-trace bugs at runtime.

Context Window Limitations and Engineering Solutions: A large language model's "Context Window" refers to the maximum number of tokens the model can process in a single inference. Even top models like Claude 3.5 with 200K token ultra-long context are still insufficient for real enterprise projects — a medium-sized Java backend project easily exceeds millions of lines of code. When the context is filled up or conversation rounds become too numerous, the model exhibits "forgetting" phenomena, starting to ignore earlier constraints. The four-layer architecture of the Harness system is essentially an "external memory system" that persists key constraints through structured files and injects them on demand with each invocation, engineering around the physical limitations of the context window.

Harness AI Engineering Programming is a methodology proposed to systematically solve these problems. It's not a tool, but a complete engineering thinking framework.

Detailed Breakdown of the Four-Layer Engineering Architecture

The core of this system is the Rules + Skills + Wiki + Changes four-layer architecture. Each layer solves problems of different dimensions, progressively building upon each other — none can be omitted.

Rules (Rule Layer): Defining Behavioral Boundaries for AI

This is the foundation of the entire system, defining the hard constraints that AI programming must follow. Specifically including:

• Code style standards (indentation, naming, comment format, etc.)
• Naming conventions (rules for variables, functions, classes, and files)
• Architecture patterns (layered architecture, module division standards)
• Prohibited anti-patterns (e.g., forbidding direct database connection manipulation in the Service layer)

Rules ensure that every line of code generated by AI conforms to team and project standards, eliminating the problem of "AI-written code with chaotic, inconsistent styling" at the source.