AI coding? Then it would be better if it likes

Introduction

---

In fast -moving software projects, documentation often tries to keep up with the effort. Folder structures evolve, testing practices improve, coding standards shift and tools are updated – usually without updates to documents. Traditionally, after coding, documentation is often considered outdated, incomplete or inconsistent if the current status of the code base does not reflect. However, documentation is essential: it standardizes the entire team's practices and plays an important role on board new developers.

In the AI ​​era, documentation has become even more critical. Good documentation provides the context that AI tools can be used to understand the structure, patterns and goals of your project. This improves the quality of code generation, refractory proposals and a general AI compliance with your team practices. Today allows AI Writing the exchange documentation to the left– If it was previously coding, testing and designing it in its development cycle.

By integrating AI-assisted documents into everyday development, teams can create a continuous feedback chain where documents develop in sync with code. This shift makes documentation a living and reliable part of the static artifact of the project – not only for human developers but also to increase the efficiency of AI.

This article explores how AI can be used to automate and streamline documentation, making it an integrated part of the software life cycle from post-development. By documenting the codes, teams can ensure that the documents are up to date and relevant.

Markdown Configuration (MDC)

---

Markdown Configuration (MDC) refers to the use of structured labeling files-only to traditional documentation, but also for machine-readable configuration, which is easy to understand in people and tools. In modern development workflows, MDCs define project-based settings, coding standards, architectural reviews, component data, and even creation or implementation instructions.

Think of them as a mix of documentation and light configuration files for writing, easy to control.

If they are consistently structured and enriched with notes, these files will become powerful resources – not only for boarding developers, but also for AI tools that use the project context to generate codes, refractor and documentation.

Technical documentation as a living property

---

Technical documentation is important for boarding, maintenance and ensuring the continuity of the whole team. A well -documented project will help new team members understand the system architecture and introduce consistent development practices from the first day.

The problem? Documentation often changes. It is once written, then forgotten – marking updates, ignoring new features and reflecting architectural changes. This causes confusion, wasted time and a growing technical debt.

Here the signing configuration files shine. These structured documents serve the dual goals: developers are readable and interpreted by machines. In proper care, they provide a centralized, version -controlled truth source for your engineering practice.

By integrating these documents into the life cycle of development -and using AI to keep them up to date -they change a Live knowledge baseTo. AI can analyze changes in the code base and recommend updates or even generate new documentation, ensuring that everything remains in sync.

Project structure

One important sign of labeling (MDC) file is project-structure.mdcTo. This file describes the layout of the global folder of the project with the name of the catalogs and files. A well -documented structure helps developers quickly navigate in the code base, find the appropriate components and create new files that follow well -established patterns.

A clear structure is not only beneficial to people – this is also a big advantage for AI tools. With a documented layout, AI does not have to scan the whole project. Instead, it can use folder conventions and nomination schemes to find and generate files more efficiently and generate recommendations that meet the project organization.

The consistent project structure also reduces the risk of adding files in the wrong place or after inconsistent naming. Over time, it will help maintain clean, large -scale architecture as the project grows.

# Project Structure

## Main Structure

  - **Modular Structure:** Organize your application into logical modules based on functionality (e.g., `controllers`, `models`, `routes`, `middleware`, `services`).
  - **Configuration:** Separate configuration files for different environments (development, production, testing).
  - **Public Assets:** Keep static assets (CSS, JavaScript, images) in a dedicated `public` directory.
  - **Views:** Store template files in a `views` directory. Use a template engine like EJS or Pug.
  - **Example Structure:**

  my-express-app/
  ├── controllers/
  │   ├── userController.js
  │   └── productController.js
  ├── models/
  │   ├── user.js
  │   └── product.js
  ├── routes/
  │   ├── userRoutes.js
  │   └── productRoutes.js
  ├── middleware/
  │   ├── authMiddleware.js
  │   └── errorMiddleware.js
  ├── services/
  │   ├── userService.js
  │   └── productService.js
  ├── config/
  │   ├── config.js
  │   └── db.js
  ├── views/
  │   ├── index.ejs
  │   └── user.ejs
  ├── public/
  │   ├── css/
  │   │   └── style.css
  │   ├── js/
  │   │   └── script.js
  │   └── images/
  ├── app.js         # Main application file
  ├── package.json
  └── .env           # Environment variables
      
## File Naming Conventions

  - **Descriptive Names:** Use clear and descriptive names for files and directories.
  - **Case Convention:** Use camelCase for JavaScript files and directories.  For components consider PascalCase.
  - **Route Files:** Name route files according to the resource they handle (e.g., `userRoutes.js`, `productRoutes.js`).
  - **Controller Files:** Name controller files according to the resource they handle (e.g., `userController.js`, `productController.js`).
  - **Model Files:** Name model files after the data model they represent (e.g., `user.js`, `product.js`).

## Module Organization

  - **ES Modules:** Use ES modules (`import`/`export`) for modularity.
  - **Single Responsibility Principle:** Each module should have a single, well-defined responsibility.
  - **Loose Coupling:** Minimize dependencies between modules to improve reusability and testability.

 ## Component Architecture

  - **Reusable Components:** Break down the application into reusable components (e.g., UI components, service components).
  - **Separation of Concerns:** Separate presentation logic (views) from business logic (controllers/services).
  - **Component Composition:** Compose complex components from simpler ones.

### Code Splitting Strategies

  - **Route-Based Splitting:** Split code based on application routes to reduce initial load time. Use dynamic imports (`import()`) to load modules on demand.
  - **Component-Based Splitting:** Split code based on components, loading components only when they are needed.

For example, in the Express application, you can document the utility, packages or scripts, as well as tools such as turbopo, which are used in Monorepo settings.

Testing

Another Valuable MDC file is testing.mdcwhich describes your project testing chores-used tensnologies, file structures, appointment conventions, test types (unit, integration, end to the end), mockery strategies and test commands.

Testing is the main part of the development cycle. This prevents regressions, increases the developer's confidence and ensures consistent quality. Standardizing testing practices by projects facilitates the operation of engineers with several code base.

This documentation is particularly beneficial for AI-abnormal development. If AI understands your test setting, this test can be written, updated and completed more effectively. A powerful approach is leading AI to test-based development (TDD) first, then generating the code to satisfy these tests.

AI can even run a test kit, malfunction and repair (or implement). Feeding IT test reports allows it to detect gaps and make proposals to improve general reliability.

# Testing Guidelines

This document outlines the project's testing standards and practices using Playwright.

## Test Structure

1. All tests must be placed in the `tests` directory
2. Tests should be organized by feature or component
3. File naming convention: `featureName.test.ts` or `componentName.test.ts`

## Test Execution

- Tests are run using Playwright through Bun
- Execute tests with `bun run test`
- Tests are configured to run in parallel by default

\```bash
# Run all tests
bun run test
\```

## Data Management

- Test data must be created programmatically before tests
- All test data must be cleaned up after tests complete
- Use test hooks for setup and teardown:

\```typescript
// Example test with data setup and cleanup
import { test, expect } from '@playwright/test';

test.describe('Recipe feature', () => {
  let testRecipeId: string;
  
  test.beforeEach(async ({ request }) => {
    // Create test data
    const response = await request.post('/api/recipes', {
      data: {
        title: 'Test Recipe',
        ingredients: ['Ingredient 1', 'Ingredient 2'],
        instructions: ['Step 1', 'Step 2']
      }
    });
    const data = await response.json();
    testRecipeId = data.id;
  });
  
  test.afterEach(async ({ request }) => {
    // Clean up test data
    await request.delete(`/api/recipes/${testRecipeId}`);
  });
  
  test('should display recipe details', async ({ page }) => {
    // Test implementation
  });
});
\```

## Feature Coverage

- Tests must cover all requirements specified in feature files
- Reference feature requirements by adding a comment with the feature name:

\```typescript
// Covers @login feature: User can sign in with email and password
test('user can sign in with valid credentials', async ({ page }) => {
  // Test implementation
});
\```

- Ensure all scenarios from feature files have corresponding tests
- Mark tests that cover specific feature scenarios with appropriate tags


## Prisma Mock
\```ts
import { beforeEach } from "vitest";
import prisma from "@/utils/__mocks__/prisma";

vi.mock("@/utils/prisma");

describe("example", () => {
  beforeEach(() => {
    vi.clearAllMocks();
  });

  it("test", async () => {
    prisma.group.findMany.mockResolvedValue([]);
  });
});
\```

## Best Practices

1. Isolate tests to prevent interdependencies
2. Use descriptive test names that explain the behavior being tested
3. Favor page object models for complex UI interactions
4. Minimize test flakiness by using robust selectors
5. Include appropriate assertions to verify expected behaviors
6. Use test.only() during development but remove before committing
7. Keep tests focused on a single behavior or functionality

Its stack.mdc The file defines your project approved technologies, libraries and tools – using instructions and best practices. This is particularly important in cooperation or AI-assisted environments.

Without clear definitions, AI tools can introduce excess dependency, inconsistent patterns or foreign libraries. By clearly documenting Kirna, you set the boundaries and equip your team and AI with a shared tool kit. Result: cleaner, more consistent, high quality code.

# Tech Stack Overview

## Frontend
- React (18.x) – Component-based UI development
- Tailwind CSS (3.x) – Utility-first CSS framework
- Vite – Fast bundler and dev server

## Backend
- Node.js (18.x) – Runtime environment
- Express – REST API framework
- Mongoose – MongoDB ODM

## Testing
- Jest – Unit and integration testing
- Supertest – HTTP assertions for Express apps

## Tooling
- ESLint – Code linting
- Prettier – Code formatting
- Husky + lint-staged – Pre-commit hooks
- Turborepo – Monorepo orchestration

Its stack.mdc is a list of primary technologies and addictions in the project. Use smaller rules to specify the installation steps, examples of use, and specific application patterns specific for each tool or addiction.

# UI Components and Styling

## UI Framework
- Use Shadcn UI and Tailwind for components and styling
- Implement responsive design with Tailwind CSS using a mobile-first approach

## Install new Shadcn components

\```sh
npx shadcn@latest add COMPONENT
\```

Example:

\```sh
npx shadcn@latest add progress
\```

Feature documentation

---

Functioning documentation is often overlooked, but it is essential for bringing cooperation, maintenance and engineering to the product's objectives.

Well -structured feature-name.mdc The file works like a functional ledger for your product. It combines salmon between product operators, engineers and QA and offers an important context for AI-helpable workflows.

Each function document should include:

• Title: Function Clear, a concise name

• Description: A brief explanation of the purpose and behavior of the function

• GHERKIN scenarios: BDD-style specifications that describe user interactions and results

• Technical design and decisions: The main architectural choices and compromise

• Implementation Status: The scenarios applied

• User flux: Visual how users interact with the function

Gherkin's scenarios are particularly valuable for AI. They provide a structured, real world behavior-so-that AI generates appropriate tests instead of general or inaccurate. Handing AI-generated tests in Ghkin ensures that they reflect actual user flows and acceptance criteria.

# User Authentication System

## Feature Overview

**Title:** Comprehensive User Authentication System
**Description:** A complete authentication system allowing users to sign up, log in, recover passwords, manage sessions, and access protected routes with role-based permissions.

## User Stories & Acceptance Criteria

### Primary User Story
As a user of the X platform, I want a secure and intuitive authentication system so that I can access personalized features while ensuring my account remains secure.

### Gherkin Scenarios

#### Registration Flow

**Scenario 1: New User Registration**
Given I am an unregistered user on the signup page
When I enter a valid email "[email protected]"
And I enter a valid username "newuser"
And I enter a valid password that meets strength requirements
And I confirm my password correctly
And I accept the terms and privacy policy
And I click the "Create Account" button
Then my account should be created successfully
And I should receive a confirmation email
And I should be redirected to the login page with a success message

**Scenario 2: Registration with Validation Errors**
Given I am an unregistered user on the signup page
When I enter an invalid email format
Or I enter a username that is too short
Or I enter a password that doesn't meet strength requirements
Or my password confirmation doesn't match
And I click the "Create Account" button
Then I should see specific validation error messages for each invalid field
And my account should not be created

**Scenario 3: Registration with Existing Email**
Given I am on the signup page
When I enter an email that is already registered
And I complete all other fields correctly
And I click the "Create Account" button
Then I should see an error message indicating the email is already in use
And I should be offered a link to the login page
And I should be offered a link to the password recovery flow

#### Authentication Flow

**Scenario 4: Successful Login**
Given I am a registered user on the login page
When I enter my registered email
And I enter my correct password
And I click the "Log In" button
Then I should be authenticated successfully
And I should be redirected to the dashboard
And my authentication status should persist across page refreshes

**Scenario 5: Failed Login Attempts**
Given I am on the login page
When I enter correct email but incorrect password 3 times in succession
Then I should see a CAPTCHA challenge on my 4th attempt
And if I fail 5 total attempts, I should be temporarily rate-limited
And I should see a message suggesting password recovery

**Scenario 6: Remember Me Functionality**
Given I am on the login page
When I enter valid credentials
And I check the "Remember Me" option
And I click the "Log In" button
Then my session should persist even after browser restart
Until I explicitly log out or the extended session expires

#### Password Management

**Scenario 7: Password Recovery Request**
Given I am on the "Forgot Password" page
When I enter my registered email address
And I click the "Reset Password" button
Then I should receive a password reset email
And I should see a confirmation message on the page

**Scenario 8: Password Reset**
Given I have received a password reset email
When I click the reset link in the email
And I enter a new valid password
And I confirm the new password
And I submit the form
Then my password should be updated successfully
And I should be redirected to the login page with a success message

#### Session Management

**Scenario 9: Session Timeout**
Given I am logged in but inactive for the session timeout period
When I try to access a protected route
Then I should be redirected to the login page
And I should see a message indicating my session has expired

**Scenario 10: Manual Logout**
Given I am logged in
When I click the "Logout" button in the navigation
Then I should be logged out immediately
And I should be redirected to the home page
And I should no longer have access to protected routes

#### Authorization & Access Control

**Scenario 11: Role-Based Access**
Given I am logged in with "user" role
When I attempt to access an admin-only route
Then I should be denied access
And I should see an "Unauthorized" message

**Scenario 12: Auth State in UI**
Given I am logged in
When I view the navigation bar
Then I should see my username/avatar
And I should see logout option
And I should not see login/signup options

## Technical Design and Decisions

### Component Architecture
- **AuthProvider**: Context provider for global auth state
- **LoginForm**: Component handling user login
- **SignupForm**: Component handling user registration
- **PasswordResetForm**: Component for password reset
- **ProtectedRoute**: HOC/middleware for route protection
- **UserMenu**: Dropdown with user options including logout

### Data Models
\```typescript
interface User {
  id: string;
  email: string;
  username: string;
  created_at: string;
  last_login: string;
  role: 'user' | 'admin';
  profile_image?: string;
}

interface Session {
  access_token: string;
  refresh_token: string;
  expires_at: number;
  user: User;
}

interface AuthState {
  session: Session | null;
  user: User | null;
  isLoading: boolean;
  error: string | null;
}
\```

### API Endpoints
- `POST /auth/signup` - Register new user
- `POST /auth/login` - Authenticate user
- `POST /auth/logout` - End user session
- `POST /auth/reset-password` - Request password reset
- `PUT /auth/reset-password` - Complete password reset
- `GET /auth/session` - Validate and refresh session
- `PUT /auth/profile` - Update user profile

### Technical Constraints
- Use Supabase Auth for authentication backend
- Implement client-side validation with Zod
- Store tokens securely using HTTP-only cookies
- Implement CSRF protection for auth operations
- Support social login with OAuth providers (Google, GitHub)
- Ensure compliance with GDPR for account data

## Implementation Progress

- [X] User Registration (Signup)
- [X] User Authentication (Login)
- [ ] Password Recovery Flow
- [ ] Session Management
- [ ] Role-Based Access Control
- [ ] Profile Management
- [ ] Social Login Integration

## Flow Diagram

\```mermaid
flowchart TD
    A[User visits site] --> B{Has account?}
    B -->|No| C[Signup Flow]
    B -->|Yes| D[Login Flow]
    
    C --> C1[Complete signup form]
    C1 --> C2{Validation OK?}
    C2 -->|No| C1
    C2 -->|Yes| C3[Create account]
    C3 --> C4[Send confirmation]
    C4 --> D1
    
    D --> D1[Complete login form]
    D1 --> D2{Valid credentials?}
    D2 -->|No| D3{Too many attempts?}
    D3 -->|No| D1
    D3 -->|Yes| D4[Show CAPTCHA/rate limit]
    D4 --> D1
    D2 -->|Yes| D5[Create session]
    D5 --> E[Redirect to Dashboard]
    
    F[Forgot Password] --> F1[Request reset]
    F1 --> F2[Send email]
    F2 --> F3[Reset password form]
    F3 --> F4{Valid new password?}
    F4 -->|No| F3
    F4 -->|Yes| F5[Update password]
    F5 --> D1
    
    G[Protected Routes] --> G1{Active session?}
    G1 -->|Yes| G2{Has permission?}
    G1 -->|No| D
    G2 -->|Yes| G3[Show content]
    G2 -->|No| G4[Show unauthorized]
\```

Create and update the documentation using AI

---

Traditionally, the documentation requires manual effort. However, with large language models (LLMs) and code-conscious AI assistants, much of this work can be automated.

One effective method is to define the templates for generating MDC files. Templates determine the structure, the required fields and formatting rules to AI create consistent and high-quality documents.

Templates

Templates describe each document type format. These include often:

• Examples: Good entries for imitation

• AI instructions: How to interpret the template

• Update the triggers: Events such as new routes or tool changes that require updates

# Feature Requirement Template

As a Product Owner, use this template when documenting new feature requirements.

# Features Location

How to add new feature to the project

1. Always place rule files in PROJECT_ROOT/.cursor/rules/features:
    \```
    .cursor/rules/
    ├── your-feature-name.mdc
    ├── another-feature.mdc
    └── ...
    \```

2. Follow the naming convention:
    - Use kebab-case for filenames
    - Always use .mdc extension
    - Make names descriptive of the feature's purpose

3. Directory structure:
    \```
    PROJECT_ROOT/
    ├── .cursor/
    │   └── rules/
    │       ├── features
    |       |   └── your-feature.mdc
    │       └── ...
    └── ...
    \```

4. Never place feature files:
    - In the project root
    - In subdirectories outside .cursor/rules/features
    - In any other location

## Structure

Each feature requirement document should include:

1. **Feature Overview**
   - Title
   - Brief description

2. **User Stories & Acceptance Criteria**
   - Primary user story
   - Gherkin scenarios (Given/When/Then)
   - Edge cases

3. **Flow Diagram**
   - Visual representation of the feature flow
   - Decision points
   - User interactions

4. **Technical Design and Decisions**
   - Component architecture
   - Data models
   - API endpoints
   - State management approach
   - Technical constraints
   - Dependencies on other features
   - Performance considerations

5. **Implementation Progress**
   - A checklist with the already implemented Scenarios

## Example

\```
---
description: Short description of the feature's purpose
globs: optional/path/pattern/**/* 
alwaysApply: false
---
# Recipe Search Feature

## Feature Overview

**Title:** Recipe Search Enhancement
**Description:** Add advanced filtering capabilities to the recipe search function allowing users to filter by ingredients, cooking time, and dietary restrictions.

## User Stories & Acceptance Criteria

### Primary User Story
As a user with dietary restrictions, I want to filter recipes by specific ingredients and dietary requirements so that I can find suitable recipes quickly.

### Gherkin Scenarios

**Scenario 1: Basic Ingredient Filtering**
Given I am on the recipe search page
When I enter "chicken" in the ingredient filter
And I click the "Search" button
Then I should see only recipes containing chicken
And the results should display the matching ingredient highlighted

**Scenario 2: Multiple Dietary Restrictions**
Given I am on the recipe search page
When I select "Gluten-free" from the dietary restrictions dropdown
And I also select "Dairy-free" 
Then I should see only recipes that satisfy both dietary restrictions
And each recipe card should display the dietary tags

**Scenario 3: No Results Found**
Given I am on the recipe search page
When I enter a very specific combination of filters that has no matches
Then I should see a "No recipes found" message
And I should see suggestions for modifying my search
And a "Clear all filters" button should be visible

## Technical Design and Decisions

### Component Architecture
- **SearchForm**: Client component that contains filter UI elements
- **RecipeResults**: Server component that fetches and renders filtered recipes
- **RecipeCard**: Reusable component that displays recipe information with dietary tags
- **EmptyState**: Component showing no results found message and suggestions

### Data Models
\```typescript
interface Recipe {
  id: string;
  title: string;
  ingredients: string[];
  cookingTime: number;
  dietaryTags: string[];
  image: string;
}

interface SearchFilters {
  ingredients: string[];
  dietaryRestrictions: string[];
  maxCookingTime?: number;
}
\```

### API Endpoints
- `GET /api/recipes/search` - Accepts query parameters for filtering recipes
  - Parameters: ingredients, dietaryRestrictions, maxCookingTime
  - Returns: Array of Recipe objects matching criteria

### State Management
- Use React Query for server state management
- Local component state for filter UI
- URL query parameters to make searches shareable and bookmarkable

### Technical Constraints
- Filter operations must complete within 500ms
- Support for mobile-responsive design
- Accessibility compliant (WCAG 2.1 AA)

### Dependencies
- Requires completed Recipe Database schema
- Uses shared UI component library for filter elements

## Implementation Progress

- [X] Scenario 1: Basic Ingredient Filtering
- [X] Scenario 2: Multiple Dietary Restrictions
- [ ] Scenario 3: No Results Found

## Flow Diagram

\```mermaid
flowchart TD
    A[User visits recipe page] --> B{Search or Filter?}
    B -->|Search| C[Enter keywords]
    B -->|Filter| D[Select filters]
    C --> E[Submit search]
    D --> E
    E --> F{Results found?}
    F -->|Yes| G[Display results]
    F -->|No| H[Show no results message]
    H --> I[Suggest filter modifications]
    I --> J[Provide 'Clear filters' option]
    G --> K[User selects recipe]
\```
\```

## AI Instructions

- Make the feature description concise but complete.
- Write Gherkin scenarios that cover the primary use cases and edge cases.
- Include a flow diagram that shows the user journey and system responses.
- Ensure all acceptance criteria are testable.
- Specify any technical constraints or requirements that might affect implementation.
- Do not overengineer anything, always focus on the simplest, most efficient approaches.

Role

Instead of administering an update logic to any template, you can define role to handle the file updates. This keeps your templates clean and avoids adding rule logic in context when you do not need it. The role usually includes:

• Description – What does the role represent

• Responsibility – for which it is responsible

• Operations – what can it do

• Examples of action – how these actions apply in real situations

This modular approach allows AI to work with intent, acting on roles instead of rewriting healthy documents each time.

# Instructions

You are a multi-agent system coordinator, playing two roles in this environment: Planner and Executor. You will decide the next steps based on the current state in the TASKS.md file. Your goal is to complete the user's final requirements.

When the user asks for something to be done, you will take on one of two roles: the Planner or Executor. Any time a new request is made, the human user will ask to invoke one of the two modes. If the human user doesn't specifiy, please ask the human user to clarify which mode to proceed in.

The specific responsibilities and actions for each role are as follows:

# Role Descriptions

## Planner

**Responsibilities**

Perform high-level analysis, break down tasks, define success criteria, evaluate current progress. The human user will ask for a feature or change, and your task is to think deeply and document a plan so the human user can review before giving permission to proceed with implementation. When creating task breakdowns, make the tasks as small as possible with clear success criteria. Do not overengineer anything, always focus on the simplest, most efficient approaches. Analyze existing code to map the full scope of changes needed. Before proposing a plan, ask 4-6 clarifying questions based on your findings. Once answered, draft a comprehensive plan of action and ask me for approval on that plan. 

**Actions** 

Revise the TASKS.md file to update the plan accordingly.

### Task List Maintenance

1. Update the task list as you progress:
   - Mark tasks as completed by changing `[ ]` to `[x]`
   - Add new tasks as they are identified
   - Move tasks between sections as appropriate

2. Keep "Relevant Files" section updated with:
   - File paths that have been created or modified
   - Brief descriptions of each file's purpose
   - Status indicators (e.g., ✅) for completed components

3. Add implementation details:
   - Architecture decisions
   - Data flow descriptions
   - Technical components needed
   - Environment configuration

### AI Instructions

When working with task lists, the AI should:

1. Regularly update the task list file after implementing significant components
2. Mark completed tasks with [x] when finished
3. Add new tasks discovered during implementation
4. Maintain the "Relevant Files" section with accurate file paths and descriptions
5. Document implementation details, especially for complex features
6. When implementing tasks one by one, first check which task to implement next
7. After implementing a task, update the file to reflect progress
8. Break down features into tasks with specific success criteria
9. Clearly identify dependencies between tasks

### Example Task Update

When updating a task from "In Progress" to "Completed":

\```markdown
## In Progress Tasks

- [ ] Implement database schema
- [ ] Create API endpoints for data access

## Completed Tasks

- [x] Set up project structure
- [x] Configure environment variables
\```

Should become:

\```markdown
## In Progress Tasks

- [ ] Create API endpoints for data access

## Completed Tasks

- [x] Set up project structure
- [x] Configure environment variables
- [x] Implement database schema
\```

[...]

To draw applications

Tensile applications are a natural moment to refresh documentation – and the perfect place to involve AI. Each code change indicates a change in knowledge. Whether it is a new route, a referor or a new addiction, is usually a update for documentation that fits. However, in practice, these updates are often missed during code reviews.

By integrating AI's workflow of your tensile application, you can:

• Identify if documentation updates are required
• Recommend or generate the necessary changes
• Review and confirm the changes before joining

Challenges

---

Although AI-helped documentation and MDCs offer great advantages, it is not easy to increase these multiple teams and projects.

Simple for one, hard for many

In small projects, the maintenance of MDCs is controlled. Everyone knows the code base and communication is fast. But in a large organization, dozens of repos become difficult.

A small rule change – for example, renaming the service folders – can be triggered by a cascade:

1. Update a central template or rule
2. Find out where other projects are different
3. Sync, tools and structure between teams

The case of a cascade

The biggest challenge is distributionTo:

• How do you notify each rule of the rule?
• How to identify sync projects?
• How can you ruin updates without things?

Without this system, the fragment and projects drifting – losing the purpose of the shared documentation.

In addition, successful implementation requires more than just automation – it requires trained engineers who can make short, effective instructions and evaluate their performance. Measuring rapid results is critical to ensure that AI driven updates do not impair the quality or accuracy of the reactions over time.

Conclusion

---

As software development becomes more sophisticated, documentation can no longer be a follow -up. In an AI-Assist era, it does not only mean that it helps people to be aligned-this means giving machines the context they need to help us build better software.

Markdown's configuration files offer a practical way to overcome this gap. They serve both people and machines, and when they are related to AI tools, they become dynamic assets that develop with the code base.

Selecting documentation – Development of workflow – makes it a strategic advantage from static load. This improves boarding, ensures consistency and increases the reliability of AI.

But scaling this approach takes the intention. As your engineering organization grows, you need processes and tools to ensure alignment, to manage changes to the rules and to maintain the quality of documentation by projects. In addition, successful implementation requires more than just automation – it requires trained engineers who can make short, effective instructions and evaluate their performance. Measuring rapid results is critical to ensure that AI driven updates do not impair the quality or accuracy of the reactions over time.

Right, AI doesn't just write your documents. This will help expand your culture.

The future of documents is not after development. It is administered, automated and always synchronized – with your team, tools and code.

References

---