Practical Guide to AI-Generated Backend API Documentation: From Database Tables to Complete API Docs

In today's world where frontend-backend separation has become the norm, clear API documentation is often the critical bottleneck for team collaboration. The traditional approach requires backend developers to manually review Controllers, Mappers, and entity classes, organizing request methods, parameters, and return values one by one—a labor-intensive process prone to omissions. Based on the AI programming tutorial by Bilibili content creator Huang Junhua (Teacher Huang), this article introduces how to leverage AI to quickly organize and generate standardized API documentation, enabling developers working with mini-programs, Apps, Vue.js, and other frontend technologies to integrate directly.

Why Use AI to Organize Backend API Documentation

When a backend system is complete and you want to implement frontend-backend separation, the frontend might use various technology stacks such as mini-programs, Apps, or Vue.js—making standardized API documentation essential.

Frontend-backend separation is an architectural pattern that fully decouples the user interface from server logic. In traditional MVC architecture, the backend renders pages and returns complete HTML, while the frontend only handles minimal interaction enhancements. Under frontend-backend separation, the backend only provides RESTful API endpoints returning JSON data, and the frontend fetches data via HTTP requests to render pages independently. The advantages of this pattern include parallel development, independent technology stack choices, flexible deployment, and the ability for a single API to serve multiple clients including Web, mini-programs, and Apps simultaneously. However, the core challenge is that API documentation becomes the sole "contract" between both parties, and documentation quality directly determines collaboration efficiency.

The problem is that a mature project's source code often already contains numerous endpoints scattered across various Controllers. Manually searching and verifying each one is not only time-consuming but error-prone.

Teacher Huang's approach is straightforward: don't dig through the code yourself—let AI do it. The core logic is: if an endpoint already exists, organize it directly into documentation; if it doesn't exist, generate the endpoint first, then output the documentation. This "check existence, reuse if found" strategy avoids reinventing the wheel and ensures consistency between documentation and code.

Breaking Down the AI Documentation Generation Workflow

The entire process can be broken down into clear steps. Understanding this "thinking process" is crucial for reusing this pattern.

Step 1: Locate Database Tables and Related Code

Taking "company content" endpoint organization as an example, the operator first sends the database table structure (in this case, the company settings table) to the AI with explicit instructions. Upon receiving the request, the AI first searches the workspace for the corresponding table structure, then locates related code based on the table.

A key point here: AI works backward from the database table to find the code. In mainstream backend frameworks like Java Spring Boot, code is typically organized in a three-layer architecture: the Controller layer handles HTTP requests and returns responses as the direct entry point for endpoints; the Service layer encapsulates business logic, handling data validation and transaction management; the Mapper layer (also called the DAO layer) handles database interactions and SQL queries. Entity classes are the code-level mapping objects of database tables. Understanding this layering is crucial for AI's code-tracing logic—AI needs to trace along the Entity→Mapper→Service→Controller chain to fully reconstruct an endpoint's complete picture. Since the query target is "company settings," its first step is to lock onto the table and related code, then further locate the corresponding entity class, Mapper, Service, and Controller.

Step 2: Check Whether the Endpoint Already Exists

The AI sequentially searches for entity classes, continues tracing through the Mapper, and ultimately locates the Controller. In this case, the company endpoint already exists in the Controller—meaning it was written when the program was originally developed. This means that for frontend-backend separation, the frontend can directly call this existing endpoint without redevelopment.

The reason large language models can "read" project code and complete this search process relies on the vast amount of open-source code and technical documentation they encountered during training. Models can understand code structure, recognize annotations (such as Spring's @GetMapping, @PostMapping), and parse method signatures and return types. With IDE plugin assistance (such as Cursor, GitHub Copilot), AI can directly access the project's file system to perform cross-file code tracing. This capability makes "tracing backward from database tables to find Controllers" possible—AI is essentially simulating an experienced developer's code-reading process, just at far greater speed.

Step 3: Automatically Generate Markdown Documentation

Once the endpoint's existence is confirmed, AI enters the documentation generation phase. It first checks whether an API documentation folder exists in the root directory (creating one if it doesn't), then generates a Markdown document like 01.md within it. The documentation content covers the request method, access path, return format, and more.

Markdown is a lightweight markup language that has become the de facto standard format for technical documentation due to its concise syntax, strong readability, and ease of version control (it can be stored directly in Git repositories). Compared to Word documents, Markdown files are plain text supporting diff comparison and collaborative editing; compared to online documentation platforms, it doesn't depend on specific services and can be opened in any editor. In API documentation scenarios, Markdown can clearly display code blocks, tables, lists, and other structured information, and can be converted into attractive online documentation sites with tools like Docsify and VuePress.

What Does the Auto-Generated API Documentation Include

The auto-generated API documentation is quite comprehensive, covering virtually all information needed for frontend integration:

• Endpoint description: Such as retrieving company-related information, including company profile, honors, development history, etc.
• Request method: Clearly specified as a GET request, returning JSON format, with no parameters required.
• Access example: Can be verified directly through a browser.
• Code examples: Provides calling examples using Ajax and other methods.
• Response structure: Includes status code (code 200 indicates success), message, and data fields.

The response structure here follows the RESTful API unified response format convention. REST (Representational State Transfer) is an API design style emphasizing resource orientation and HTTP semantics. Common conventions include: using GET to retrieve resources, POST to create resources, PUT to update resources, DELETE to delete resources; URL paths represent resource hierarchy (e.g., /company/setting represents the company settings resource); returning a unified JSON structure (typically containing a code status field, message field, and data body). This unified format allows the frontend to handle all endpoint responses with a single set of common logic, greatly simplifying frontend network request encapsulation.

Interestingly, the return data in the documentation is actual database data. In this case, the database contains 4 records from ID 1 to ID 4, and the endpoint returns exactly these 4 records, perfectly matching the database content and verifying the endpoint's correctness.

Notable Details in the Documentation

Beyond basic endpoint information, the AI-generated documentation also addresses practical issues in frontend usage. For example:

• Return field descriptions: Explains the meaning of status codes, messages, and data fields one by one.
• Important notes: Since content may contain HTML tags, the documentation specifically reminds frontend developers to use HTML rendering methods.
• Multi-framework calling examples: Thoughtfully provides rendering code examples for vanilla JS, Vue.js, React, and other frameworks.
• Multiple endpoint coverage: The documentation distinguishes between "get all company content" and "get single content by company ID" (e.g., setting/content with company ID 1) scenarios.

These details transform the documentation from a cold endpoint list into a complete integration guide that can be directly delivered to frontend developers.

A Reusable API Documentation Generation Pattern

The greatest value of this method lies in forming a reusable standardized pattern. Regardless of which module's endpoints need to be organized later, you can follow the same workflow:

1. Prepare the database table structure information.
2. Send a request to AI, clearly specifying the rule: "check if it exists; if so, organize it; if not, generate it."
3. Specify the target directory for documentation generation.
4. AI automatically queries tables, traces code, and generates standardized documentation.

For team collaboration, this means the backend focuses on website endpoint development while the frontend takes the auto-generated documentation to implement mini-programs, Apps, or other clients. Both sides collaborate based on the same documentation, dramatically reducing communication costs. As Teacher Huang puts it: "If you don't give them documentation, how are they supposed to work?" AI solves precisely this tedious yet essential step.

It's worth noting that this pattern also offers excellent extensibility. When the project iterates and endpoints change, you simply re-execute the same workflow, and AI regenerates documentation based on the latest code, ensuring documentation and code stay perpetually in sync—the exact pain point that traditional hand-written documentation struggles most to maintain.

Conclusion

The application of AI in API documentation organization demonstrates the practical value of large language models in engineering practice—it doesn't replace developer thinking but automates repetitive, mechanical organizing work. Through the fixed workflow of "tracing code backward from database tables, checking existence, and generating complete documentation," developers can quickly produce high-quality API documentation with multi-framework examples. For frontend-backend separation projects, this is undoubtedly a practical technique for improving collaboration efficiency. Once you master this pattern, organizing endpoints for any module becomes a straightforward, highly efficient process.