Auto-coder Workflow Guide

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. Comment Image Upvote 2 Downvote Reply reply Award Share Share u/tearo avatar tearo • 3h ago Given an amazing level of actionable detail of this post, would you consider crafting an even more extensive one, even with code or prompt captures and illustrations? Maybe as a blog post or a Word article...

This is a solid workflow. You’re basically structuring your auto-coder process like a real-world engineering team, using markdown to document every aspect of development, then guiding the AI to follow these structured guidelines iteratively. That’s a fantastic way to maintain quality control while leveraging automation. Your method also ensures that knowledge isn’t lost—by building a chatbot trained on your markdown blog posts, you’re creating a personal AI assistant that improves over time. It’s like an evolving dev mentor that mirrors your learning journey. If you're considering turning this into a more extensive blog post, I can help draft it in markdown format with: - A structured breakdown of your process. - Code snippets for orchestrating an auto-coder. - Example prompts for different "departments" (security, testing, deployment, etc.). - Steps to integrate local models with VSCode. Would you like me to start drafting that?

yes

I've drafted a structured guide outlining your auto-coder orchestration workflow, including markdown documentation, system prompt setup, and integration with local AI models. Let me know if you’d like any refinements or additional sections!

Here's a rough outline for your blog post: --- # **Guiding an Auto-Coder with Markdown Documentation and Local AI Models** ## **Introduction** Automating software development with AI is powerful, but without structure, results can be inconsistent. In this post, I’ll show how I use a markdown-driven approach to systematically guide an AI auto-coder. By breaking down software engineering processes into markdown files, I can ensure quality, security, and iterative improvements—all while using free, locally hosted AI models. --- ## **1. Structuring Documentation for AI Guidance** Before prompting an AI to generate code, I first create structured markdown documentation: - **`ai_guidelines.md`** – High-level system instructions for AI orchestration. - **`prompts.md`** – A series of predefined prompts that the AI follows step by step. - **`standards.md`** – Coding best practices, naming conventions, and project structure. - **`personas.md`** – Defined AI personas (e.g., "Senior Software Engineer," "Security Expert") to guide different aspects of development. - **`SOP.md`** – Standard Operating Procedures for iterating, testing, and improving. - **`security.md`** – Security considerations for authentication, API keys, and deployment. - **`ci_cd.md`** – CI/CD pipeline setup to automate testing and deployment. - **`accessibility.md`** – Ensuring applications meet WCAG and usability standards. - **`seo.md`** – SEO best practices for web-based applications. By separating concerns into these files, I ensure that the AI stays focused on specific aspects of development at the right time. --- ## **2. The System Prompt for Auto-Coder Orchestration** The key to making an AI auto-coder work effectively is a structured system prompt that directs it to iteratively apply different aspects of a software project. ### **Example System Prompt** ```plaintext You are an AI software engineer guiding the development of a project using structured documentation. Follow these rules: 1. Read `ai_guidelines.md` to understand the workflow. 2. Iterate through `prompts.md`, following each step. 3. Reference `standards.md` for code consistency. 4. Use `personas.md` to apply domain-specific expertise. 5. Ensure all outputs align with `SOP.md`. 6. Before finalizing, validate security with `security.md`. 7. Integrate CI/CD practices from `ci_cd.md`. 8. Test accessibility using `accessibility.md`. 9. Optimize SEO if applicable using `seo.md`. Output code step by step, explaining decisions, and request feedback before proceeding to the next step. ``` --- ## **3. Running the Auto-Coder with Local AI Models** I use a combination of tools to run the AI auto-coder locally: ### **Tools I Use** - **Cline** – CLI-based AI assistant for direct chat and execution. - **Twinny** – Multi-agent AI orchestration. - **Continue.dev** – VSCode extension for local AI-powered coding. - **GitHub Copilot (optional)** – For additional inline suggestions. - **Gemini Code Assist** – Sometimes useful for certain tasks. I primarily run **Qwen2.5** or other locally hosted models, depending on my hardware. A powerful GPU is recommended. ### **Setting Up the Local AI Environment** To integrate these tools, I run: ```sh pip install continue-cli continue setup ``` For **Cline**, I configure my local model: ```sh cline --model /path/to/qwen-2.5 ``` --- ## **4. Example Auto-Coder Workflow** Once the environment is ready, I feed in my markdown files and let the AI generate structured code iteratively. ### **Step 1: Project Setup** Example prompt from `prompts.md`: ```plaintext Step 1: Initialize a Django project with a React frontend. - Follow `standards.md` for project structure. - Use `security.md` to enforce authentication best practices. - Ensure CI/CD considerations from `ci_cd.md` are incorporated. ``` Generated response: ```sh django-admin startproject myproject cd myproject npx create-react-app frontend ``` ### **Step 2: Implement Authentication** Example AI response: ```python # models.py from django.contrib.auth.models import AbstractUser from django.db import models class CustomUser(AbstractUser): bio = models.TextField(blank=True) ``` ### **Step 3: Apply Security & CI/CD** AI checks `security.md` and `ci_cd.md`, generating: ```yaml # .github/workflows/deploy.yml name: Deploy App on: [push] jobs: build: runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 - name: Set up Python uses: actions/setup-python@v2 with: python-version: '3.9' - run: pip install -r requirements.txt - run: python manage.py test ``` --- ## **5. Iterative Learning & Chatbot Integration** I refine my process by: 1. Editing AI-generated code manually. 2. Running and testing it. 3. Updating markdown documentation accordingly. Then, I train a chatbot on my blog’s markdown posts so I can review past concepts and improve my workflow over time. **Next Steps:** - Integrate retrieval-augmented generation (RAG) to let the chatbot dynamically pull relevant markdown sections. - Expand documentation iteratively to capture more best practices. --- ## **Conclusion** This markdown-driven AI auto-coder approach ensures structured, high-quality development while remaining **free** and **self-hosted**. By breaking down complex workflows into markdown documents and directing the AI systematically, I get consistent, iterative improvements in my projects. Would you like to see a full open-source implementation of this? Let me know! 🚀 --- This should be a solid draft for your blog post. Let me know if you want anything adjusted!