Auto-coder Development Plan

create a plan of action for me to use an auto coder to create the project I have been working on the last few days using this methodology: I use vanilla VSCode and create a ai_guidelines.md file as well as all other documentation, like all of the prompts I would need to input into an auto-coder in order to complete the entire project would be in one .md file and then standards, personas, SOP, security considerations, deployment, ci/cd etc are all described in separate .md Then in the system prompt I create a basic orchestration which instructs the auto-coder to iteratively apply each of the departments of a full tech company to the application of the prompt. So you have the series of prompts for each aspect already created and ready. You have testing incorporated into each iteration as well as considerations for security, accessibility, SEO, SOP, etc. Then you input each prompt, the system prompt directs the auto-coder to iteratively follow through with each department's .md procedures and this is one way you can help guide the auto-coder. I use a variety of tools, cline, twinny, github copilot, gemini code assist, all extensions in vscode. With cline, twinny, continue.dev and other extensions like those you can use locally hosted models to run something like qwen2.5 of whatever model your hardware supports which needs to be beefy if you want anything that actually works. Personally what I do now is just chat in the chat window or console and copy paste and edit together a guide which I can follow along with, learn the concepts, and create the project, and then publish the guide on my blog which I am also going to use to create a teaching chatbot trained on the markdown blog posts, this way I can iteratively build a chatbot with everything I have taught myself so I can always review anything and reinforce any concept I have already covered. It also allows me to easily add more content to be mastered in the future. Anyway. I find that following along with a guide to be a better way. Because I edit the guide myself and test it out by building it and then correcting the guide when I am done. This helps me learn while I am working on something and also to create future resources I can refer back to. This way is also free. Because I just use freely available models to write the guides and try to do as much of the coding myself by building off of things I have already created which I just refer back to a lot, thus the current program I am working on to help me chat with my markdown files.

Here’s a structured **Plan of Action** for implementing your auto-coder methodology using a structured markdown-based approach. This plan ensures iterative development, integrates all essential technical departments, and supports your learning and documentation goals. --- ### **1. Initial Setup & Tooling** #### **Tools & Environment** - **VSCode Extensions**: - Cline, Twinny, Continue.dev, GitHub Copilot, Gemini Code Assist - Local LLMs (Qwen2.5, Mixtral, or any model your hardware supports) - **Frameworks & Services**: - Locally hosted models - Markdown-based documentation approach - GitHub/GitLab for version control - Deployment: Netlify, Render, or other free-tier platforms --- ### **2. Documentation-Driven Development** #### **Markdown File Structure** 1. `ai_guidelines.md` – Defines AI-assisted development approach, constraints, and methodology. 2. `prompts.md` – Stores all prompts required for auto-coder interaction. 3. `standards.md` – Outlines coding conventions, best practices, and style guides. 4. `personas.md` – Defines roles (frontend engineer, backend dev, security analyst, etc.). 5. `sop.md` – Standard Operating Procedures for iterative development. 6. `security.md` – Security considerations for development. 7. `deployment.md` – CI/CD pipeline setup and hosting strategy. 8. `testing.md` – Testing methodologies, automation strategies, and debugging. 9. `accessibility.md` – Ensuring compliance with accessibility best practices. 10. `seo.md` – Optimizing for search engines and discoverability. **→ This structured documentation allows the auto-coder to iteratively apply each department’s considerations when generating code.** --- ### **3. System Prompt for Auto-Coder** The system prompt will instruct the auto-coder to **iteratively** follow through each department's `.md` procedures in sequence. #### **Example System Prompt for Auto-Coder** > "You are an AI software architect following a structured development process. Each phase adheres to industry standards documented in Markdown files. > **Workflow:** > - Read `prompts.md` to understand the project requirements. > - Follow `standards.md` to ensure coding consistency. > - Implement the `personas.md` approach to simulate different roles. > - Execute step-by-step following `sop.md`, ensuring iterative progress. > - Validate security using `security.md` guidelines. > - Prepare deployment using `deployment.md`. > - Ensure comprehensive testing using `testing.md`. > - Optimize accessibility (`accessibility.md`) and SEO (`seo.md`). > > After each phase, review outputs, apply fixes, and refine the implementation." --- ### **4. Workflow Execution** 1. **Define the Project Scope** - Populate `prompts.md` with project-specific prompts. - Define **expected outcomes** and **acceptance criteria**. 2. **Initialize the Auto-Coder** - Load the system prompt. - Begin iteration through each Markdown file in logical order. 3. **Iterative Development Process** - **Step 1:** Generate base project structure (`standards.md`) - **Step 2:** Implement core functionality (`prompts.md`) - **Step 3:** Apply personas (`personas.md`) - **Step 4:** Ensure procedural alignment (`sop.md`) - **Step 5:** Integrate security best practices (`security.md`) - **Step 6:** Configure deployment (`deployment.md`) - **Step 7:** Automate testing (`testing.md`) - **Step 8:** Optimize for accessibility & SEO (`accessibility.md`, `seo.md`) - **Step 9:** Review, refine, and iterate 4. **Manual Review & Testing** - You review each auto-generated section, make necessary refinements, and test the code. 5. **Documentation & Blog Guide Creation** - Once the project is built successfully, convert it into a structured blog post for future reference. - The blog post serves as a **training dataset** for your AI chatbot. --- ### **5. Chatbot for Markdown File Interaction** - Train a local chatbot on your markdown guides. - Enable **retrieval-based Q&A** on your past projects. - Implement embedding-based search (e.g., ChromaDB) to find relevant sections. --- ### **6. Benefits of This Approach** ✅ **Structured, repeatable, and scalable development.** ✅ **Ensures best practices across all software disciplines.** ✅ **Uses free/local LLMs, minimizing costs.** ✅ **Creates a self-reinforcing learning system.** ✅ **Future-proofs your workflow by documenting everything.** --- ### **7. Next Steps** 1. **Draft initial `ai_guidelines.md` and `prompts.md`** 2. **Set up local auto-coder environment** 3. **Test an initial project with this methodology** 4. **Refine process based on real-world implementation** 5. **Build chatbot for Markdown-based interaction** --- Would you like a sample `ai_guidelines.md` file or an example `prompts.md` to kickstart the process? 🚀

yes

Here's a structured **`ai_guidelines.md`** file and an example **`prompts.md`** file to kickstart your auto-coder workflow. --- ## **📜 `ai_guidelines.md` (AI Development Framework)** ```md # AI-Assisted Development Guidelines ## 🔹 Overview This document outlines the methodology for using AI-assisted coding in a structured, iterative development workflow. ## 🔹 Principles 1. **Documentation-Driven** – All prompts, standards, and guidelines are in markdown files. 2. **Iterative Development** – The AI follows a structured process across multiple software disciplines. 3. **Human Review & Testing** – AI-generated code is reviewed, refined, and tested at each phase. 4. **Security-First** – Adheres to secure coding best practices. 5. **Continuous Learning** – Guides are updated based on real-world implementation. ## 🔹 Workflow 1. **Initialize AI System** - Load `system_prompt.md` into the auto-coder. - Use locally hosted models for full control. 2. **Iterate Through Development Phases** - Each `.md` file represents a department in a tech company. - AI processes each phase sequentially. 3. **Validate, Test & Deploy** - Run AI-generated code through human review & testing. - Optimize based on results. ## 🔹 Markdown File Structure - `prompts.md` → All auto-coder prompts. - `standards.md` → Coding conventions & best practices. - `personas.md` → Defines engineering roles for AI-guided workflows. - `sop.md` → Standard Operating Procedures for development. - `security.md` → Security considerations. - `deployment.md` → CI/CD pipeline & hosting. - `testing.md` → Test strategies & automation. - `accessibility.md` → Compliance with accessibility best practices. - `seo.md` → Search Engine Optimization strategies. ## 🔹 AI Models & Tools - **LLMs** → Qwen2.5, Mistral, Mixtral, or any supported model. - **Extensions** → Cline, Twinny, Continue.dev, GitHub Copilot. - **Editor** → Vanilla VSCode. --- ``` --- ## **📜 `prompts.md` (AI-Driven Development Prompts)** ```md # AI Development Prompts ## 🔹 1. Project Initialization **Prompt:** > "Generate a clean project structure for a full-stack web application using Django (backend) and React (frontend). Follow best practices outlined in `standards.md`. Include a `README.md` with setup instructions." ## 🔹 2. Backend Development **Prompt:** > "Develop the Django backend with authentication and API endpoints. Ensure compliance with `security.md`. Document the API in OpenAPI format." ## 🔹 3. Frontend Development **Prompt:** > "Create a React frontend with Tailwind CSS. Ensure UI components follow accessibility standards (`accessibility.md`)." ## 🔹 4. Security Implementation **Prompt:** > "Analyze the backend and frontend security risks based on `security.md`. Implement CSRF protection, XSS mitigation, and secure authentication." ## 🔹 5. Testing Automation **Prompt:** > "Generate unit tests and integration tests for backend and frontend using Jest and Pytest. Follow `testing.md` guidelines." ## 🔹 6. Deployment Strategy **Prompt:** > "Prepare CI/CD workflows for automated deployment on Render and Netlify. Ensure versioning and rollback mechanisms based on `deployment.md`." --- ``` --- This provides a solid foundation to **structure AI-driven development**, ensuring all departments are covered while keeping your methodology organized and iterative. Do you need templates for `standards.md`, `security.md`, or `deployment.md` next? 🚀

yes

Here are the templates for **`standards.md`**, **`security.md`**, and **`deployment.md`** to guide your AI-assisted development process. --- ## 📜 `standards.md` (Coding Standards & Best Practices) ```md # Coding Standards & Best Practices ## 🔹 General Coding Guidelines - Follow **PEP 8** for Python and **Airbnb Style Guide** for JavaScript. - Use **meaningful variable names** and **docstrings/comments**. - Keep functions and methods **short** (≤20 lines). - Ensure **type annotations** in Python and **PropTypes/TypeScript** in React. ## 🔹 Backend Development (Django) - Use **Django REST Framework** for APIs. - Apply **serializer validation** and **pagination** in API responses. - Use **environment variables** for secrets (`.env` files). - Log all **critical actions** with Django’s logging system. ## 🔹 Frontend Development (React) - Follow **component-driven development** (Atomic Design). - Use **React Query** or equivalent for API data fetching. - Ensure **ARIA compliance** for accessibility. - Minimize **re-renders** with memoization techniques (`useMemo`, `useCallback`). ## 🔹 Database & ORM - Prefer **PostgreSQL** over MySQL. - Use **migrations** and **seeds** for database version control. - Optimize queries with **indexes** and **lazy loading** where needed. ## 🔹 Version Control (Git) - Follow the **GitFlow** branching model. - Commit messages should follow the **Conventional Commits** format: - `feat: Add user authentication` - `fix: Resolve CORS issue` - `chore: Update dependencies` --- ``` --- ## 📜 `security.md` (Security Considerations) ```md # Security Best Practices ## 🔹 General Security Measures - Use **HTTPS** and **secure headers** (CSP, HSTS, X-Frame-Options). - Store **secrets in environment variables** – never in the codebase. - Use **Multi-Factor Authentication (MFA)** for admin accounts. ## 🔹 Backend Security - Sanitize **user input** to prevent **SQL Injection & XSS**. - Use **JWT** or **OAuth2** for authentication (short-lived tokens). - Rate-limit API requests to prevent **DDoS attacks**. - Hash passwords using **Argon2**, **bcrypt**, or **PBKDF2**. ## 🔹 Frontend Security - Implement **Content Security Policy (CSP)**. - Validate all user inputs on the frontend before submission. - Use **React Helmet** to manage security-related meta tags. ## 🔹 Database Security - Restrict **direct database access** using **firewall rules**. - Enable **automatic backups** and **encryption at rest**. ## 🔹 Deployment Security - Apply **least privilege principle** for all IAM roles. - Enable **monitoring and logging** for security audits. --- ``` --- ## 📜 `deployment.md` (CI/CD & Hosting Strategy) ```md # CI/CD & Deployment Strategy ## 🔹 Hosting & Infrastructure - **Backend**: Deploy Django API on **Render** with a PostgreSQL database. - **Frontend**: Deploy React app on **Netlify** with CI/CD integration. ## 🔹 CI/CD Workflow - Use **GitHub Actions** for automated testing and deployment. - Run **pre-deployment checks** (linting, tests, security audits). - Deploy via **blue-green deployment** to minimize downtime. ## 🔹 Steps for Automated Deployment 1. **Push to `main` branch** → Triggers CI pipeline. 2. **Run unit tests** for backend & frontend. 3. **Build & Lint Code** → Ensures quality control. 4. **Deploy Backend** (Render) & **Deploy Frontend** (Netlify). 5. **Run Post-Deployment Tests** to verify functionality. ## 🔹 Rollback Strategy - Keep the last **three stable versions** for rollback. - Use **database migrations** with version control to prevent data loss. --- ``` --- ### **Next Steps?** Would you like a **`testing.md`** or **`seo.md`** file next? Or do you need adjustments to these? 🚀

testing.md and seo.md files

Here are the **`testing.md`** and **`seo.md`** files to integrate testing strategies and SEO best practices into your AI-guided development process. --- ## 📜 `testing.md` (Testing Strategy & Automation) ```md # Testing Strategy & Automation ## 🔹 Testing Philosophy - Follow **Test-Driven Development (TDD)** for critical features. - Ensure all **business logic is covered** by tests. - Automate as much testing as possible to reduce human error. ## 🔹 Types of Tests ### 1️⃣ **Unit Tests** - Validate individual functions and methods. - Use **Pytest** for backend tests. - Use **Jest** or **React Testing Library** for frontend tests. **Example (Backend, Django + Pytest):** ```python def test_create_user(client): response = client.post("/api/users/", {"username": "testuser", "password": "securePass123"}) assert response.status_code == 201 ``` **Example (Frontend, React + Jest):** ```jsx test("renders login button", () => { render(<Login />); expect(screen.getByText(/Login/i)).toBeInTheDocument(); }); ``` ### 2️⃣ **Integration Tests** - Ensure components and API endpoints work together. - Use **Django TestCase** for backend integration testing. - Use **Cypress** for full end-to-end UI testing. ### 3️⃣ **End-to-End (E2E) Testing** - Simulate real user behavior across the system. - Use **Playwright** or **Cypress** for testing workflows. ### 4️⃣ **Performance Testing** - Use **Locust** for backend load testing. - Use **Lighthouse** for frontend performance analysis. ## 🔹 Continuous Testing in CI/CD - Run all tests before deploying to production. - Use **GitHub Actions** or **Continue.dev** for test automation. - Ensure **code coverage** is at least **80%**. ## 🔹 Security & Accessibility Tests - Use **Bandit** for Python security auditing. - Use **OWASP ZAP** for web app penetration testing. - Use **axe-core** for automated accessibility testing. --- ``` --- ## 📜 `seo.md` (SEO Best Practices) ```md # SEO Best Practices ## 🔹 General SEO Strategy - Ensure **fast page load speeds** (use Lighthouse for performance audits). - Follow **mobile-first design** principles. - Use **semantic HTML5 elements** for better indexing. - Implement **structured data (Schema.org)** for rich search results. ## 🔹 On-Page SEO ### 1️⃣ **Title & Meta Tags** - Titles: **50-60 characters**, with primary keywords first. - Meta Descriptions: **120-160 characters**, including a CTA. - Use **React Helmet** or Django's `{% block meta %}` for dynamic metadata. ### 2️⃣ **Keyword Optimization** - Identify primary and secondary keywords. - Use keywords in **H1-H3 headers, first 100 words, and alt attributes**. ### 3️⃣ **Internal Linking & Navigation** - Maintain a **clear site structure** with breadcrumbs. - Link related articles to increase engagement. ## 🔹 Technical SEO ### 1️⃣ **Page Speed & Performance** - Use **lazy loading** for images (`loading="lazy"`). - Optimize images with **WebP** format. - Minimize **JavaScript blocking** by deferring scripts. ### 2️⃣ **Crawlability & Indexing** - Ensure **robots.txt** and **sitemap.xml** are configured. - Use **canonical tags** to prevent duplicate content. - Avoid JavaScript-heavy content that isn’t SEO-friendly. ### 3️⃣ **Accessibility & User Experience** - Ensure contrast ratios meet **WCAG 2.1 standards**. - Use **ARIA attributes** for screen readers. - Enable **keyboard navigation** for interactive elements. ## 🔹 Off-Page SEO - Build **high-quality backlinks** from authoritative sources. - Encourage **social media shares** for organic traffic. - Monitor site rankings with **Google Search Console**. --- ``` --- ### **Next Steps?** Would you like a **`sop.md`** (Standard Operating Procedures) or **`personas.md`** next? 🚀

both

Here are **`sop.md`** (Standard Operating Procedures) and **`personas.md`** (User & AI Personas) for your AI-guided project workflow. --- ## 📜 `sop.md` (Standard Operating Procedures) ```md # Standard Operating Procedures (SOP) ## 🔹 Overview This document outlines the **standard procedures** for software development, AI-assisted coding, security practices, and deployment. These SOPs ensure consistency, security, and efficiency across all projects. --- ## 🔹 Development Workflow 1️⃣ **Project Initialization** - Create a `README.md` with an overview and setup instructions. - Define project structure and create necessary `.md` documentation. - Initialize **Git repository** and commit an empty project with `git init`. 2️⃣ **Coding Guidelines** - Follow [PEP 8](https://peps.python.org/pep-0008/) for Python and [ESLint](https://eslint.org/) for JavaScript. - Use **docstrings** and **JSDoc** for function documentation. - Follow **branching strategy**: - `main` → Production-ready - `dev` → Feature development - `feature/{name}` → New features 3️⃣ **AI-Assisted Coding** - Use **Continue.dev, Twinny, and Copilot** for autocompletions. - Maintain an **ai_guidelines.md** file with all AI instructions. - Validate AI-generated code before committing. --- ## 🔹 Security Procedures 1️⃣ **Code Security** - Scan for vulnerabilities using `bandit` (Python) or `npm audit` (JS). - Use **.env files** for sensitive credentials (never commit them). 2️⃣ **Authentication & Access Control** - Use **OAuth2, JWT, or API keys** for authentication. - Enforce **role-based access control (RBAC)**. 3️⃣ **Secure Deployment** - Use **Docker containers** for isolated environments. - Regularly update dependencies and monitor for security patches. --- ## 🔹 Testing & Deployment 1️⃣ **Automated Testing** - Run tests locally before pushing code. - Use **GitHub Actions** or **Jenkins** for CI/CD. 2️⃣ **Deployment Checklist** - Ensure all **SEO, accessibility, and security tests** pass. - Deploy to **Netlify, Vercel, or Render** for frontend. - Use **Supabase, PostgreSQL** for databases. --- ## 🔹 Documentation & Knowledge Management 1️⃣ **Project Docs** - Maintain `docs/` directory with all markdown files. - Update documentation **before closing any task**. 2️⃣ **Blog & Internal Knowledge** - Publish findings and guides on [danielkliewer.com](https://danielkliewer.com/). - Train AI chatbot on project markdown files for review. --- ``` --- ## 📜 `personas.md` (User & AI Personas) ```md # Personas for AI & User Interaction ## 🔹 AI Personas ### 1️⃣ **Auto-Coder** (AI Developer) - Role: Writes code iteratively based on **ai_guidelines.md**. - Strengths: Fast, structured, follows best practices. - Weaknesses: Needs **human oversight** to validate outputs. ### 2️⃣ **AI Code Reviewer** - Role: Analyzes pull requests and suggests improvements. - Tools: Uses **SonarQube, PyLint, ESLint** for static analysis. ### 3️⃣ **SEO & Content Advisor** - Role: Ensures **SEO best practices** in metadata and content. - Checks: **Keyword density, accessibility, structured data**. --- ## 🔹 User Personas ### 1️⃣ **Solo Developer (You)** - Needs: A **structured workflow** with AI-assisted development. - Goal: Build and document projects efficiently while **learning**. - Interaction: Uses **CLI tools, VSCode extensions, local models**. ### 2️⃣ **Freelance Client** - Needs: Wants **secure, maintainable software**. - Concern: Clear **SOPs and documentation** for long-term use. - Interaction: Expects professional **GitHub repository** with a well-documented project. ### 3️⃣ **Beginner Developer (Reader of Your Blog)** - Needs: Wants to learn from **your guides** and replicate projects. - Goal: Understand AI-assisted coding and **best practices**. - Interaction: Uses your blog, chatbot, and project examples for reference. --- ## 🔹 How These Personas Are Used - **AI Personas** guide how auto-coding tools interact with your workflow. - **User Personas** ensure project documentation is useful for **clients and learners**. --- ``` --- ### **Next Steps?** Would you like an **`ai_guidelines.md`** next to define orchestration for your auto-coder? 🚀

yes

Here’s your **`ai_guidelines.md`**, which outlines how your auto-coder should operate, incorporating structured orchestration across different software development departments. --- ## 📜 `ai_guidelines.md` (Auto-Coder Orchestration) ```md # AI Coding Guidelines & Orchestration ## 🔹 Overview This document provides the **system prompt and structured workflow** for AI-assisted development. It ensures that the auto-coder follows a **step-by-step, department-based approach** to building a project, incorporating **testing, security, SEO, SOP, deployment, and documentation** at every stage. --- ## 🔹 System Prompt (Auto-Coder Instructions) **Role:** > You are an **AI software engineering assistant**. Your goal is to iteratively build a project while following a structured methodology. Each phase follows the workflows of **a professional tech company**, including Development, QA, Security, Deployment, and Documentation. **Core Directives:** 1️⃣ **Follow `sop.md` for all standard procedures.** 2️⃣ **Iterate through each department, ensuring thorough testing and security compliance.** 3️⃣ **Log each decision and justification in a markdown format.** 4️⃣ **Never overwrite existing code without validation.** 5️⃣ **Check `personas.md` to align with project requirements.** --- ## 🔹 Orchestration: Step-by-Step Auto-Coder Execution ### 1️⃣ **Project Initialization** 📌 **Goal:** Set up project structure and documentation. ✅ Read `sop.md` for directory structure. ✅ Initialize Git, create `README.md`, and define `.gitignore`. --- ### 2️⃣ **Development Phase** 📌 **Goal:** Write modular, well-documented code. ✅ Implement features iteratively. ✅ Use docstrings and comments based on coding standards. ✅ Follow `testing.md` for unit test integration. --- ### 3️⃣ **Testing & Quality Assurance (QA)** 📌 **Goal:** Ensure code correctness and reliability. ✅ Run unit tests and integration tests. ✅ Validate AI-generated code manually. ✅ Follow `testing.md` for coverage requirements. --- ### 4️⃣ **Security & Compliance** 📌 **Goal:** Apply security best practices to code and infrastructure. ✅ Scan for vulnerabilities (`npm audit`, `bandit`). ✅ Validate API authentication (`JWT, OAuth2`). ✅ Ensure **.env management** and secret handling. --- ### 5️⃣ **SEO & Accessibility** 📌 **Goal:** Optimize for search engines and user accessibility. ✅ Implement structured data (`schema.org`). ✅ Validate WCAG accessibility compliance. ✅ Follow `seo.md` for meta tags, headers, and performance tweaks. --- ### 6️⃣ **Deployment & CI/CD** 📌 **Goal:** Automate deployment and ensure continuous integration. ✅ Set up GitHub Actions for testing and linting. ✅ Deploy to **Netlify/Vercel/Render** based on project type. ✅ Follow `sop.md` deployment checklist. --- ### 7️⃣ **Documentation & Knowledge Retention** 📌 **Goal:** Maintain clear and updated documentation. ✅ Update `docs/` directory with each iteration. ✅ Ensure **all AI-generated contributions** are manually reviewed. ✅ Publish insights on [danielkliewer.com](https://danielkliewer.com/) for long-term knowledge retention. --- ## 🔹 AI-Assisted Coding Workflow | Phase | Tools Used | AI Prompts Involved | |-------------|-------------------------------------------------|----------------------------| | Initialization | Git, Markdown, VSCode Extensions | Setup repository, create docs | | Development | Continue.dev, Copilot, Twinny | Implement core features | | QA & Testing | PyTest, Jest, GitHub Actions | Write and run tests | | Security | Bandit, npm audit, OWASP guidelines | Scan for vulnerabilities | | SEO & A11y | Lighthouse, schema.org, WCAG Checker | Optimize metadata, performance | | Deployment | Docker, Netlify, Render, Supabase | Automate CI/CD pipelines | | Docs & Knowledge | Markdown, Blog, AI Chatbot | Publish and refine guides | --- ## 🔹 AI Usage Guidelines ✅ **Use AI to assist, not replace human review.** ✅ **Manually validate all AI-generated code.** ✅ **Ensure AI follows structured development workflows.** ✅ **Always iterate through all development phases before deploying.** --- ## 🔹 Conclusion By using **structured orchestration**, your auto-coder can efficiently build and optimize projects while ensuring quality, security, and maintainability. Follow this guide to make AI-assisted development **reliable, efficient, and free** using local models and VSCode extensions. --- ``` --- ### **Next Steps?** Would you like me to draft **`testing.md`** and **`seo.md`** next? 🚀

you already did

Great! Now that you have `ai_guidelines.md`, `testing.md`, and `seo.md`, your workflow is well-structured. ### **Next Steps:** 1. **Create `sop.md`** – A standard operating procedure document to unify workflows. 2. **Create `personas.md`** – Define roles like Developer, QA, Security, etc., to ensure AI follows structured guidelines. 3. **Set Up Your Auto-Coder in VSCode**: - Load `ai_guidelines.md` into the system prompt. - Configure **Continue.dev**, **Cline**, or **Twinny** to use local LLMs. - Use `Continue.dev` to iterate through your markdown-based orchestration. - Test automation through iterative prompts. 4. **Iterate & Improve**: - Run AI-generated code and manually refine it. - Publish your guide on your blog. - Train your chatbot with new content. Let me know if you want `sop.md` or `personas.md` drafted next! 🚀