How to Use Zencoder for Automating Your Coding Workflows With AI

In the last few years, the tech industry has been running over creating LLMs, AI, agents, and their integrations with other third parties. If you’re already using AI agents in your coding workflows, you know that there are lots of solutions out there. However, not every solution is good for every case.

In this tutorial, you’ll learn what Zencoder is and how its AI agents can fit into your coding workflows.

By the end of this tutorial, you’ll understand:

• What Zencoder is and why it can be a good fit for your AI coding workflows.
• How to use Zencoder agents to create a sample portfolio website for a backend Python developer and to create a Python file that merges PDFs.
• How Zencoder can be used to create the documentation for your codebases.

Explore the full tutorial to get your first experience with Zencoder, including setting up the agents and visualizing the results of their work.

What Is Zencoder?

Zencoder is an AI orchestration tool that allows you to create agents that streamline your everyday workflows and tasks. It does so by integrating with several third parties, granting companies to simplify workflows across different departments ranging from engineering to HR.

For engineers specifically, Zencoder helps you by:

• Creating goal-driven automations across several third parties like Jira, Slack, Notion, Gmail, Calendar, and more than 100 other tools.
• Writing code, intercepting bugs, and writing documentation by prompting its agents.
• Managing multi-repo agents, creating skills for your favourite LLM, integrating with MCPs, and IDEs like VS Code and JetBrains.
• Providing you with predefined templates you can use for your workflows, suggesting the third parties to integrate with Zencoder’s agents.

Regarding code, Zencoder agents are capable of creating and working with all the main programming languages. This is because they can be connected with all the main LLMs you already use. So, the technical capabilities are tied to the specific model you choose.

How to Use Zencoder for Creating a Portfolio Website in Python and Documenting the Code

In this section, you’ll learn how to use Zencoder for:

1. Creating a portfolio website for a backend Python developer.
2. Writing the documentation for the website (the README file).

Follow along with this tutorial to learn how to do so step by step.

Prerequisites
To replicate this tutorial, you need the following:

• VS Code installed on your machine.
• A Zencoder account and its VS Code extension.

To meet the Zencoder prerequisite, first go to the Zencoder website, choose a license that suits your needs, and create a new account.

NOTE: Zencoder offers you a free trial for each license!

Below is what you’ll see after the registration is completed:

From the Downloads section, click on the VS Code extension button. You’ll be redirected to the VS Code marketplace page where you can download Zencoder’s extension:

After clicking on Install, the system will automatically open VS Code and install Zencoder’s extension. When installation is completed, you need to log in to your Zencoder account from VS Code. To do so, click on Zencoder in VS Code’s status bar:

To connect to your Zencoder account, click on Sign in:

When the process completes, you’ll see a success message on your browser:

Below is what you’ll see in VS Code after signing in:

Well done: Zencoder is now integrated into Vs Code. You’re ready to configure your first agent.

Step 1: Configure Your Agent and Select an LLM
Zencoder allows you to create custom agents and manage lots of settings like skills and tools:

For the sake of this tutorial, selecting Gemini Flash as the LLM and leaving anything else as their default is sufficient:

Very well. You are ready to use your Zencoder agent.

Step 2: Create the Portfolio for a Python Backend Developer Using Zencoder
To create a portfolio website for a backend Python developer, use the following prompt:

Create a portfolio website for a Python developer who specalizes in backend development. It must have: 

- An "about page" that describes the developer and their career (5+ years of experience)
- A "projects" section with 5 projects 

Make it look modern. 

Paste the prompt into Zencoder’s chat, and play it:

The agent will work on your task and create all the needed code. Whenever it considers it necessary, it will ask you to accept or reject the code it creates:

At the end of the process, the agent will create a templates/ folder containing all the HTML files and the main Python file on top of the fast API framework, for managing the backend of the portfolio website. Below is the main.py file created by the agent:

from pathlib import Path
from fastapi import FastAPI, Request
from fastapi.templating import Jinja2Templates
from fastapi.staticfiles import StaticFiles
from fastapi.responses import HTMLResponse

app = FastAPI()

# Absolute path for templates
BASE_DIR = Path(__file__).resolve().parent
templates = Jinja2Templates(directory=str(BASE_DIR / "templates"))

@app.get("/", response_class=HTMLResponse)
async def home(request: Request):
    return templates.TemplateResponse(request, "index.html", {"request": request})

@app.get("/about", response_class=HTMLResponse)
async def about(request: Request):
    return templates.TemplateResponse(request, "about.html", {"request": request})

@app.get("/projects", response_class=HTMLResponse)
async def projects(request: Request):
    projects_list = [
        {
            "title": "Scalable Microservices Architecture",
            "description": "A high-performance microservices system built with FastAPI and Kafka for real-time data processing.",
            "tech": ["Python", "FastAPI", "Kafka", "Docker", "PostgreSQL"],
            "image": "<https://images.unsplash.com/photo-1558494949-ef010cbdcc51?auto=format&fit=crop&q=80&w=800>"
        },
        {
            "title": "AI-Powered Analytics Engine",
            "description": "Backend engine for processing large datasets using Pandas and Scikit-learn, exposed via a GraphQL API.",
            "tech": ["Python", "Pandas", "GraphQL", "Graphene", "Redis"],
            "image": "<https://images.unsplash.com/photo-1551288049-bebda4e38f71?auto=format&fit=crop&q=80&w=800>"
        },
        {
            "title": "Secure Payment Gateway Integration",
            "description": "Robust and secure backend for processing payments with multi-factor authentication and auditing.",
            "tech": ["Python", "Django", "Stripe API", "OAuth2", "Pytest"],
            "image": "<https://images.unsplash.com/photo-1563013544-824ae1b704d3?auto=format&fit=crop&q=80&w=800>"
        },
        {
            "title": "Real-time Chat Backend",
            "description": "WebSocket-based chat server capable of handling thousands of concurrent connections using Redis Pub/Sub.",
            "tech": ["Python", "WebSockets", "Redis", "Asyncio", "NoSQL"],
            "image": "<https://images.unsplash.com/photo-1611746872915-64382b5c76da?auto=format&fit=crop&q=80&w=800>"
        },
        {
            "title": "Automated Cloud Orchestrator",
            "description": "CLI tool and backend service to automate multi-cloud deployments across AWS and GCP using Boto3.",
            "tech": ["Python", "Boto3", "AWS", "Terraform", "Serverless"],
            "image": "<https://images.unsplash.com/photo-1451187580459-43490279c0fa?auto=format&fit=crop&q=80&w=800>"
        }
    ]
    return templates.TemplateResponse(request, "projects.html",{"request": request, "projects": projects_list})

Good. The Zencoder agent created the portfolio website based on your prompt. You’re ready to see the result.

Step 3: Run the Code and See the Result
Zencoder allows you to run the code for visualizing the result directly in its CLI. In that case, it will automatically install the requirements and run uvicorn. Alternatively, you can run the code in Vs Code’s terminal. This last option is preferable if you want to install the requirements into a virtual environment.

Regardless of your choice, below is the main page of the portfolio website you’ll see:

As you can see, the agent has created the main page for a developer who specializes in creating backends in Python, with 5+ years of experience. Below is the “About” page:

The projects section is shown in the following image:

The agent replicated everything you asked in the prompt. The only thing that’s not actually perfect is the image on the first project: this is probably a hallucination by the model because the URL returns a 404.

Terrific! You created your first Python code project with Zencoder. In the next step, you’ll ask the agent to create the documentation for the entire codebase.

Step 4: Create the Documentation Using Zencoder
The Zencoder agent can be used for creating the documentation for an entire codebase. In this case, the README file is the right choice. To create it, use the following prompt:

The current repository is a codebase for a portfolio for Python developers. 
Analyze all the subfolders and create a README file that documents:
- What this repository is about
- How to use the code

Do this as a professional technical writer would by going into the right details for an audience of web developers.

The Zencoder agent will analyze all the files in the current repository and create the README. As with the previous example, it will ask you to accept or reject its job:

Below is the complete README generated by the agent:

# Python Developer Portfolio

A professional, high-performance portfolio template designed specifically for Python developers. This application leverages the speed of **FastAPI** and the utility-first styling of **Tailwind CSS** to provide a modern, responsive showcase for backend and full-stack projects.

## 🚀 Overview
This repository provides a production-ready starting point for developers who want to showcase their technical expertise with a clean, dark-themed aesthetic. It features a modular structure, async-first backend logic, and dynamic template rendering.

### Key Features
- **FastAPI Backend**: High-performance asynchronous API framework.
- **Jinja2 Templating**: Server-side rendering for improved SEO and initial load speed.
- **Tailwind CSS**: Modern UI components with a custom "Slate & Blue" dark theme.
- **Responsive Design**: Fully optimized for mobile, tablet, and desktop viewing.
- **Dynamic Projects Showcase**: Easily manageable project list with support for titles, descriptions, tech stacks, and images.

## 🛠️ Tech Stack
- **Framework**: \[FastAPI\](https://fastapi.tiangolo.com/)
- **Language**: \[Python 3.10+\](https://www.python.org/)
- **Templating**: \[Jinja2\](https://jinja.palletsprojects.com/)
- **Styling**: \[Tailwind CSS\](https://tailwindcss.com/)
- **Icons**: \[Font Awesome\](https://fontawesome.com/)
- **Server**: \[Uvicorn\](https://www.uvicorn.org/)

## 📂 Project Structure  
    .
    ├── main.py              # Application entry point and route definitions
    ├── requirements.txt      # Python dependencies
    ├── templates/           # Jinja2 HTML templates
    │   ├── base.html        # Shared layout and navigation
    │   ├── index.html       # Landing page
    │   ├── about.html       # Experience and skills page
    │   └── projects.html    # Portfolio gallery
    └── venv/                # Virtual environment (recommended)

## ⚙️ Getting Started

### Prerequisites
- Python 3.10 or higher
- `pip` (Python package installer)

### Installation 
1. **Clone the repository**:
   `
   git clone <repository-url>
   cd portfolio-project
   `

2. **Set up a virtual environment**:
   `
   python -m venv venv
   # On Windows:
   .\venv\Scripts\activate
   # On Unix/macOS:
   source venv/bin/activate
   `

3. **Install dependencies**:
   `
   pip install -r .\requirements.txt
   `

### Running the Application
Start the development server using Uvicorn:
`
uvicorn main:app --reload
`

The application will be available at **`http://127.0.0.1:8000`**. 
- **Home**: `http://127.0.0.1:8000/`
- **About**: `http://127.0.0.1:8000/about`
- **Projects**: `http://127.0.0.1:8000/projects`

## 🔧 Configuration

### Adding New Projects
Projects are currently managed in `.\main.py` within the `projects` route. To add a new project, simply append a dictionary to the `projects_list`:

`
{
    "title": "My Awesome Project",
    "description": "Short project summary...",
    "tech": ["Python", "Docker"],
    "image": "https://link-to-image.jpg"
}
`

## 📜 License
This project is open-source and available under the MIT License.

As you can see, the agent created a professional README that reports:

• What the repository is about, along with the features and the tech stack used.
• The project structure, with folders and files.
• How to get started with it, including prerequisites, installation of requirements, and how to run it.

Perfect. You’ve learned how to create the documentation of a codebase using Zencoder.

How to Use Zencoder for Creating a Python File That Merges PDFs

This tutorial, will show you the ability Zencoder agents have of creating the codebase you need along with its documentation with one prompt. In the previous tutorial, you first prompted the agent to create the codebase. In this second one, instead, you will prompt the agent asking it to create the code, the README file, and also the .gitignore.

In this case, you can use the following prompt:

Create a Python project that, given any PDF as input, it merges them into a unique PDF file. 

I also want:
- A complete and professional README file that documents all the Python file you will create, that describes what the repository is about, and how to install and use the code. Do this as a professional technical writer would by going into the right details for an audience of Python developers.
- A compiled .gitignore file

The following image shows what you’ll see when the agent finishes working:

Below is the code the agent wrote in pdf_merger.py:

    import argparse
    import os
    import sys
    from pypdf import PdfWriter
    def merge_pdfs(input_paths, output_path):
        """
        Merges multiple PDF files into a single PDF.
        Args:
            input_paths (list): List of paths to the input PDF files.
            output_path (str): Path where the merged PDF will be saved.
        """
        writer = PdfWriter()
        try:
            for path in input_paths:
                if not os.path.exists(path):
                    print(f"Error: File not found - {path}")
                    sys.exit(1)
                if not path.lower().endswith(".pdf"):
                    print(f"Error: Not a PDF file - {path}")
                    sys.exit(1)

                print(f"Appending {path}...")
                writer.append(path)
            with open(output_path, "wb") as output_file:
                writer.write(output_file)

            print(f"Successfully merged PDFs into: {output_path}")
        except Exception as e:
            print(f"An error occurred during merging: {e}")
            sys.exit(1)
        finally:
            writer.close()
    def main():
        parser = argparse.ArgumentParser(description="Merge multiple PDF files into one.")
        parser.add_argument(
            "inputs", 
            nargs="+", 
            help="List of PDF files to merge (in the order they should appear)"
        )
        parser.add_argument(
            "-o", "--output", 
            default="merged.pdf", 
            help="Name of the output PDF file (default: merged.pdf)"
        )
        args = parser.parse_args()
        merge_pdfs(args.inputs, args.output)

    if __name__ == "__main__":
        main()

What’s interesting to note is that the agent generated the Python file to use argparse, which is a library that allows you to use your IDE’s command line. This is a brilliant solution because the prompt doesn’t tell the agent to “open all the PDF files in a repository”. It tells it to “open any PDF file”. By using argparse, you can manage the order in which the Python file will open each PDF file, maintaining the order you want in the output.

This is also clear from the README file, which is the following:

    # PDF Merger
    A professional, lightweight Python utility to merge multiple PDF files into a single document. This project leverages the `pypdf` library to provide a robust and efficient command-line interface (CLI) for document management.

    ## Project Structure
    - **`.\pdf_merger.py`**: The main executable script containing the merging logic and CLI argument parsing.
    - **`.\requirements.txt`**: List of Python dependencies required to run the project.
    - **`.\.gitignore`**: Configuration file specifying untracked files that Git should ignore.

    ## Features
    - Merge any number of PDF files in a specific order.
    - Customizable output filename.
    - Error handling for missing files and non-PDF inputs.
    - Clean and informative console output.

    ## Prerequisites
    - Python 3.6 or higher.
    - `pip` (Python package installer).

    ## Installation
    1. **Clone the repository** (or download the source files).
    2. **(Recommended) Create a virtual environment**:
       `
       python -m venv venv
       source venv/bin/activate  # On Windows: venv\Scripts\activate
       `
    3. **Install the dependencies**:
       `
       pip install -r requirements.txt
       `
    ## Usage
    The script is used via the command line. You provide the paths to the PDF files you wish to merge as positional arguments.

    ### Basic Usage
    To merge files in the current directory and generate the default `merged.pdf`:
    `
    python pdf_merger.py file1.pdf file2.pdf file3.pdf
    `
    ### Specifying Output Filename
    Use the `-o` or `--output` flag to define a custom name for the resulting file:
    `
    python pdf_merger.py input_a.pdf input_b.pdf --output final_document.pdf
    `
    ### Help
    To view all available options:
    `
    python pdf_merger.py --help
    `
    ## Technical Details
    The project utilizes the `PdfWriter` class from the `pypdf` library. It iterates through the provided file paths, appends them to the writer object, and then writes the accumulated content to the specified output stream. Proper resource management is ensured through the use of `try...finally` blocks to close the writer object. 

As you can see in the “Basic Usage” section, you have to specify the names of the files. This is useful to maintain a specific order, when the pdf_merger.py will merge the PDFs.

Finally, the content of the .gitignore file is following:

    # Byte-compiled / optimized / DLL files
    __pycache__/
    *.py[cod]
    *$py.class

    # Distribution / packaging
    dist/
    build/
    *.egg-info/

    # Virtual Environment
    venv/
    env/
    .venv/
    .env/

    # IDEs
    .vscode/
    .idea/

    # OS files
    .DS_Store
    Thumbs.db

    # Output files
    merged.pdf          

Hooray! You made it to the end of your second Python tutorial using the Zencoder agent.

Conclusion

In this tutorial, you learned what Zencoder is and how to use an agent to create a codebase in Python and HTML for a portfolio website and how to create its README file.

Among the agentic solutions on the market, Zencoder stands out for its wide integration capability. This allows you to connect and integrate with dozens of third parties, automating different kinds of daily workflows.

As a final note, consider that Zencoder also suits the needs of non-technical stakeholders. In other words, the IDE integrations are just one of the possibilities because you can also use it via web chat.