DEV Community: Santiago Hernandez

How to make a Django application using GitHub Copilot

Santiago Hernandez — Sun, 17 May 2026 20:55:42 +0000

We'll develop a simple password generator Django application using GitHub Copilot agent mode. At the end we'll analyze the tradeoffs of using LLMs to develop this application. To do this we'll use the GitHub Copilot plugin for PyCharm, you can do the same thing using VS Code if you want to. I'll be using GPT-4.1 in this tutorial.

This is the repository that I'll use to make this project, you can check it if you want to see the final version of this project: https://github.com/santiago177/PasswordGenerator

Requirements

This project will be built using Django and will use GitHub Copilot to generate most of the code, you'll need the following setup:

Install Python
Install Git
Install PyCharm free version
A GitHub account

Feel free to skip to the Create a README and AGENTS file section if you feel confident creating a Django project in a GitHub repository and have the GitHub Copilot plugin already.

Creating the project and repository

Open PyCharm and create a new Django project, then name the project PasswordGenerator.

It should look like this:

Commit the boilerplate code and create a new repository for your project in GitHub by going to Git -> GitHub -> Share Project on GitHub.

Get the GitHub Copilot plugin

Go to Settings -> Plugins and type Copilot in the search bar, look for the GitHub Copilot plugin and install it, you'll need to restart PyCharm afterwards.

Open the GitHub Copilot window on the right side and log in to it using your GitHub account by clicking on Continue with GitHub. You don't need to get a premium version of GitHub Copilot but you have a limited amount of requests, that limit will be more than enough to complete this project.

You should see a chat window like this if you're successfully logged in:

Create a README and AGENTS file (Optional)

This is an optional step that helps the agent better understand your project by generating an AGENTS.md file.

Create a README.md file first. I'll use the following one:

# PasswordGenerator

This is a very simple project designed to generate random passwords.

## Description
The purpose of this project is to provide a basic tool for generating secure and random passwords. It is ideal for those who need to create passwords quickly and easily.

## Features
- Random password generation
- Simple and easy-to-understand code

## Build Mode
This project is intended to be built and managed using **agent mode**, which makes automation and task integration easier.

## Requirements
- Python 3.x

---

This project is ideal as an educational example or as a base for more advanced developments.

Having a readme file has multiple benefits, but in this particular case we want to use it to provide context to the agent so it can generate an agents instructions file.

Open a new Copilot chat after creating the README.md file and click on a button named Create/Update agent instructions.

This will initiate an agent task that will generate an AGENTS.md file, the purpose of this file is to provide a context to the agent related to your project so that it has a better idea of what it has to do. This is the AGENTS.md file that I got. You'll get a different one but it should be similar.

# AGENTS.md

## Project Overview
- **Purpose:** Simple Python tool for generating secure, random passwords. Designed for educational use or as a base for more advanced projects.
- **Current State:** Minimal starter code in `main.py` (prints a greeting). No password generation logic implemented yet.
- **Primary Language:** Python 3.x

## Key Files
- `main.py`: Entry point. All logic currently resides here. Intended to be expanded with password generation features.
- `README.md`: Project description, requirements, and intended usage.

## Developer Workflows
- **Run the project:**
  - Use `python main.py` to execute the script.
  - Can also run from IDE (e.g., PyCharm: green run button or Shift+F10).
- **No build or test scripts** are present. Add tests in future as needed.

## Patterns & Conventions
- Keep code simple and easy to understand—prioritize readability for educational purposes.
- Place all logic in `main.py` unless the project grows significantly.
- Use standard Python idioms; no custom frameworks or patterns are in use.
- No external dependencies required (as of now).

## Extending the Project
- Implement password generation logic in `main.py`.
- If adding features (e.g., CLI, GUI, tests), create new files/modules as needed and update this guide.
- Document any new conventions or workflows in this file for future agents.

## Integration Points
- None currently. No external APIs, services, or libraries are integrated.

## Example: Adding Password Generation
- Define a function (e.g., `generate_password(length: int) -> str`) in `main.py`.
- Use Python's `random` or `secrets` module for secure password generation.
- Print or return the generated password in the main execution block.

---

**Update this file as the project evolves to keep agent guidance current.**

As you can see, all this file is doing is to provide a brief explanation of what the project does. Create a commit with these changes including the AGENTS.md and README.md files.

Create the Django project

First create a directory called .github/prompts to place our prompts. We'll place our prompts here because agent mode prompts can get lengthy when you need to provide a lot of context and constraints. You can get the same result by typing prompts in the chat.

Let's test GitHub Copilot agent mode by creating a prompt instructing the agent to create the setup for this project.

Prompt

Create a file named django-setup.prompt.md inside .github/prompts with the following prompt:

# Django setup instructions
- Install django packages
- Verify installation
- Create requirements.txt file
- Create a new Django project named *PasswordGenerator*
- Create a new Django app named *generator*

After that, open a new chat in GitHub Copilot by clicking the + icon on the top right of the chat window, make sure agent mode is selected, then type and submit /django-setup

You'll be prompted multiple times by the agent to run some commands like pip install django and django-admin startproject PasswordGenerator .
Review the commands and authorize the agent to run them if they make sense to you. At the end you should have a project structure that looks like this:

Let's commit all the changes with the new files created, including the requirements.txt and django-setup.prompt.md files to continue with the next step.

Creating a view

Let's create a view using agent mode to generate a random password with custom length, the only parameter that we'll use is the length of the password.

Prompt

Create a file named create-password-view.prompt.md inside .github/prompts with the following prompt:

# Instructions

- Create a view in the generator app that generates a random password. The only argument that it takes for now is the length of the password. This should be a GET method.
- Create a complete URL setup. The URL for this view should be `/generate-password/`.
- Verify that all url files are updated to include the new URL and make sure that it works.

Run the prompt in a new chat by typing /create-password-view using agent mode and review the changes.

After running this command, the agent mode will have to add some boilerplate code to the urls.py files, but the most interesting part of it is the view that it creates. It should be similar to this:

from django.http import JsonResponse
from django.views.decorators.http import require_GET
import secrets
import string

@require_GET
def generate_password_view(request):
    try:
       length = int(request.GET.get('length', 12))
       if length < 1 or length > 128:
          return JsonResponse({'error': 'Password length must be between 1 and 128.'}, status=400)
    except (TypeError, ValueError):
       return JsonResponse({'error': 'Invalid length parameter.'}, status=400)

    alphabet = string.ascii_letters + string.digits + string.punctuation
    password = ''.join(secrets.choice(alphabet) for _ in range(length))
    return JsonResponse({'password': password})

As developers we need to always review the code that AI generates. We can see that this view receives a length parameter and generates a random password by using the secrets library. We didn't ask the agent to implement length constraints checks or to handle exceptions, but we can leave those there as they are good to have.

The agent will sometimes take freedom to implement things you didn't ask for. This can be useful sometimes but you always have the option to write an additional prompt requesting to remove that code or remove it yourself if you want to.

Testing the view with agent mode

When I ran this prompt something nice that I wasn't expecting happened, the agent mode ran the project and proceeded to test the view using curl commands.

These tests were run in the console showing that the view is working properly. If your agent doesn't run these tests you can write an additional prompt requesting to run the tests or run the server yourself and run curl "http://127.0.0.1:8000/generate-password/?length=16"

Review the changes and commit them before moving to the next step.

Creating the UI

This is a good opportunity to update the AGENTS.md file as multiple files have been modified. To do this you can open a new chat and click Update Agent Instructions.

Create a file named create-ui.prompt.md inside .github/prompts with the following prompt:

# Create UI instructions

- Create a template that displays the password generator
- The UI should have an orange faded banner that says "Password Generator"
- Add bootstrap to the project and use it to style the UI, all the elements should use bootstrap
- Below that there should be a generate password button with a numeric textbox next to it specifying the length of the password. Both of these should look pretty big.
- Add the functionality to generate a password when the button is clicked, and display the generated password below the button. Using the generate password view.
- Display the generated password in a large font below the button, make all the elements centered.

I used my own creativity and preferences to write this prompt, but you should modify it to describe how you want to stylize the UI.

Run the prompt in a new chat by typing /create-ui using agent mode and review the changes.

Error self-correction

After the agent finishes editing files it will attempt to test that the app works. If it fails it will try to self-correct. In this case the agent forgot to add the app to settings.py, but it corrected the error afterwards.

Agent mode fixing the error:

Testing the UI

At this point we have generated all the code that is needed to make the basic version of a password generator work. Let's now open the site http://localhost:8000/ in a browser. Make sure that your project is running.

This is the result that I got, which is pretty close to what I was hoping for. You'll get something different depending on the style that you described in the prompt.

Make sure that the password generation works when clicking the button, also check if errors like providing lengths that exceed the maximum are handled properly. Review the changes and commit them.

Congratulations, we've created a password generator using GitHub Copilot agent mode in just a few hours.

As you can see this UI is far from perfect, there are many improvements that can be done like making the text in the banner clearer, turn Password inside the button to lowercase or add a Length tooltip or text above the numeric textbox. That's fine for this case as this is enough to let us see that the project works. You can improve the UI from here by writing more prompts in GitHub Copilot or by modifying the code on your own.

Next steps

This is one of the simplest ways to implement a password generator. After this version there are many improvements and changes that can be done:

Add more options to the password generation like checkboxes to include or exclude numbers, capital letters, special characters etc
Improve the UI
Add a real frontend framework like React if you want to or replace Bootstrap with something like Tailwind
Refactor and reorganize UI Javascript code
Add unit tests
Refactor this project to use DRF
Try other AI models

I suggest you work on any of these tasks if you want to keep testing GitHub Copilot agent mode or develop this project further. Let me know in the comments if you'd be interested in seeing a continuation of this tutorial working on these tasks.

Final thoughts

Using an AGENTS.md and instructions files has multiple benefits but it will be more expensive to use them in the long term, as it requires the agent to use more tokens, you should evaluate the tradeoffs of using instructions files based on the cost of tokens and how much resources you have.
It took me around 3 hours to create this app while also writing this tutorial at the same time. You should be able to do this in less than an hour if your setup is ready.
I was pleasantly surprised to see that the agent was capable of testing the password generator service properly using curl and seeing it self-correct.
It was interesting to see that the agent sometimes takes the freedom to implement things you didn't ask for. These additions were good in this case but it could be problematic in other contexts, which is why we always need to review the code.
The project was intentionally designed to be very simple, with no databases and very little logic to give the agent a good chance of producing correct code in a short period of time. You'll probably start noticing mistakes if you add more complex logic or more complex context to the agent.
I personally didn't like how the agent organized the UI code. I wish the code was cleaner and more organized, separating Javascript code. These are changes that will require more prompt iterations or manual changes. You can check the code I got in my repository if you want to.
The results of developing this project using GPT-4.1 were pretty good. I'd like to make another article comparing different models like Claude and Gemini.
The review process of each change produced by the agent is not trivial and can be time consuming, you should evaluate the tradeoffs of using an AI agent or building it yourself.

How to use stacks in Python

Santiago Hernandez — Sat, 09 May 2026 03:54:10 +0000

A stack is a linear data structure where inserted elements are kept in insertion order and only the last one to be added is removed, this is also known as LIFO (last in first out) behavior.

A traditional Stack supports three operations:

Insertion or push
Peek or top
Deletion or pop

Execution times for both operations can vary slightly depending on the implementation, all three can be executed in constant times O(1) with the right data structure.

Examples

Consider the following list of numbers, let's assume the last element in the list is the last one to be inserted:

stack = [1, 7, 5, 6, 5, 12, 4]

The following operations will produce the following results and the list will behave like a stack:

stack = [1, 7, 5, 6, 5, 12, 4]
stack.pop() # Pop is a deletion operation and number 4 has been removed from the stack

print(stack[-1]) # 12 - This gives us the element at the top of the stack which is a peek operation

print(stack) # [1, 7, 5, 6, 5, 12]
stack.append(30) # Append is an insertion operation and adds an element at the end of the list
#Number 30 has been added

print(stack) # [1, 7, 5, 6, 5, 12, 30]

Let's analyze another example:

stack = []
stack.append(1)
stack.append(2)
stack.append(3)
print(stack) # [1, 2, 3]
print(stack.pop()) # 3
print(stack.pop()) # 2
print(stack.pop()) # 1
print(stack) # []

As you can see, printing the values that are removed from the stack will give us the list of elements in reverse order. This gives stacks some interesting applications we'll analyze later.

How to use stacks in Python

In the previous examples we used lists to represent stacks, however there are more ways to implement stacks that we should analyze:

Using lists

This is the approach we used in the examples. We just create a list and perform insert operations by appending elements to the end of the list.

stack = [3, 2, 5, 6]
print(stack.pop()) # 6
print(stack) # [3, 2, 5]

This approach works well and many people use it, let's check how each operation performs using lists:

Insert: O(1) Amortized
Peek: O(1)
Delete: O(1)

The reason why the complexity of insert is O(1) amortized is because in the implementation of list, a new list is created if the list grows as big as the size of its internal array. However developers came up with a smart way to reduce the amount of times this has to be done, by doubling or greatly increasing the size of the new internal array. This means that an O(n) operation will be performed very few times turning the complexity of the insert operation by O(1) amortized.

If you want to understand why amortized O(1) works at a deeper level, read how dynamic arrays handle memory allocation, it's a topic worth its own article.

Using deques

This is my preferred approach as deques use linked lists underneath, which is the optimal way to implement stacks for time performance.

from collections import deque

stack = deque()

# Push items
stack.append(1)
stack.append(2)
stack.append(3)

# Pop item (last in, first out)
top = stack.pop()  # returns 3
print(top) # 3

# Peek at top without removing
top = stack[-1]  # returns 2
print(top) # 2

print(stack)  # deque([1, 2])

Another example

from collections import deque

my_list = [3, 4, 5, 2]
stack = deque(my_list)

while stack:
    print(stack.pop()) # Prints 2, 5, 4, 3

This is the performance of stack operations using deque in Python:

Insert: O(1)
Peek: O(1)
Delete: O(1)

The difference of using a list and a deque is going to be insignificant in most cases, however there might be some special applications and corner cases where using a deque might be needed. I can imagine there are LeetCode problems where using a deque (linked list) can make the difference between passing and not passing.

Creating your own Stack class

Most of the times it's unnecessary to create your own class to utilize stacks. You can do it if you want to solve some shortcomings that lists and deques have. For example deques and lists allow you to peek elements in the middle of the stack, add or delete elements in any position, in other words you can perform operations that a stack doesn't support. You can solve this by creating your own Stack class where you have more control over the operations that are allowed.

Example:

from collections import deque

class Stack:
    def __init__(self):
        self._stack = deque()

    def push(self, item):
        self._stack.append(item)

    def pop(self):
        if not self._stack:
            raise IndexError("Pop from empty stack")
        return self._stack.pop()

    def peek(self):
        if not self._stack:
            raise IndexError("Peek from empty stack")
        return self._stack[-1]

    def __repr__(self):
        return f"Stack({list(self._stack)})"

# Usage
stack = Stack()

stack.push(1)
stack.push(2)
stack.push(3)

print(stack)          # Stack([1, 2, 3])
print(stack.peek())   # 3
print(stack.pop())    # 3
print(stack.pop())    # 2
print(stack.pop())    # 1
print(stack.pop())    # IndexError: Pop from empty stack

As this class uses a deque to represent the stack, its performance will be the same as the performance of a deque.

Applications

Stacks show up in real codebases and DSA problems. Here are some applications:

Parentheses matching
Tree traversals
DFS
Memento undo/redo

Parentheses matching

This is one of the simplest problems that can be solved using stacks. In summary what the algorithm does is to keep track of opening parentheses in a stack and as soon as you find a closing parenthesis you compare it to the one on top of the stack. Any inconsistencies mean that the parentheses are not valid.

Sample code solution for this problem: https://leetcode.com/problems/valid-parentheses/

from collections import deque


class Solution:
    def isValid(self, s: str) -> bool:
        closing_to_open = {')': '(', '}': '{', ']': '['}
        stack = deque()
        for c in s:
            if c in closing_to_open:
                if not stack or stack.pop() != closing_to_open[c]:
                    return False
            else:
                stack.append(c)
        return len(stack) == 0

This same idea can also be used to match HTML opening and closing tags, JSON objects, XML tags etc. Matching parentheses is the simplest version of this problem but there are some variations to it.

Tree traversals

Traversing trees and graphs can be done in multiple ways, you can do it recursively or iteratively. Iterative traversals are usually more efficient but you'll need data structures like stacks or queues to traverse them. Traversing a tree or any kind of graph using stacks will result in a DFS type of traversal.
We can use stacks to perform some of the main binary tree traversals:

Pre-order
In-order
Post-order

The following code shows how to perform an inorder traversal of a binary tree using stacks:

from collections import deque


class Solution:
    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        inorder = []
        stack = deque()
        node = root
        while node or stack:
            while node:
                stack.append(node)
                node = node.left
            node = stack.pop()
            inorder.append(node.val)
            node = node.right
        return inorder

This is a solution to the following problem: https://leetcode.com/problems/binary-tree-inorder-traversal/

DFS on graphs

We just saw how to perform a DFS on a tree, the same traversal can be performed on graphs. Have a look at the following problem: https://leetcode.com/problems/number-of-islands/
We are given a graph and we need to find how many connected components the graph has. This problem can be solved by performing a DFS or BFS search:

class Solution:
    def numIslands(self, grid: List[List[str]]) -> int:
        for i in range(len(grid)):
            grid[i] = ["0"] + grid[i] + ["0"]
        waterRow = ["0"] * len(grid[0])
        grid = [waterRow] + grid
        grid.append(waterRow)
        moves = [(1, 0), (0, 1), (-1, 0), (0, -1)]
        visited = set()
        islands = 0
        for i in range(1, len(grid) - 1):
            for j in range(1, len(grid[i]) - 1):
                if grid[i][j] == "1" and (i, j) not in visited:
                    islands += 1
                    stack = collections.deque()
                    stack.append((i, j))
                    visited.add((i, j))
                    while stack:
                        pos =  stack.pop()
                        for m in moves:
                            newPos = (pos[0] + m[0], pos[1] + m[1])
                            if grid[newPos[0]][newPos[1]] == "1" and newPos not in visited:
                                visited.add(newPos)
                                stack.append(newPos)
        return islands

Note: There's something funny about this solution and it is that I initially solved it using BFS with queue instead of using DFS. To turn it into DFS, all I had to do was to use a stack instead of a queue and the solution will still work. There are many problems that can be solved with both BFS or DFS without making any difference. I recommend you check articles about BFS and queues if you want to learn more about it.

Undo and redo functions

This is one of the most interesting applications of stacks. You can implement undo and redo functions using the Memento design pattern but I'll show a simplified example of it using stacks. A classic Memento implementation will use stacks too.

The following example shows the code of a TextEditor class that implements redo and undo functions using stacks:

from collections import deque

class TextEditor:
    def __init__(self):
        self.content = ""
        self._history = deque()
        self._future = deque()

    def type(self, text):
        self._history.append(self.content)
        self._future.clear()
        self.content += text

    def undo(self):
        if not self._history: return
        self._future.append(self.content)
        self.content = self._history.pop()

    def redo(self):
        if not self._future: return
        self._history.append(self.content)
        self.content = self._future.pop()

editor = TextEditor()
editor.type("Hello")
print(editor.content) # Hello
editor.type(" world")
print(editor.content) # Hello world
editor.undo()
print(editor.content) # Hello
editor.redo()
print(editor.content) # Hello world

Conclusion

The stack is a fundamental linear data structure that has many useful applications. Knowing the situations where stacks are needed to solve problems is going to bring a lot of value for you as a developer, especially in DSA problems. If you want to continue studying data structures and algorithms I'd recommend you study its FIFO counterpart the queue, trees and graph algorithms like DFS and BFS.
If you have any questions or want to discuss anything please leave a comment in the comment section.