Copilots for Creating Python Projects - First Impressions

Copilots for Creating Python Projects - First Impressions.md

Copilots for Creating Python Projects - First Impressions

1. Intro: Intent and Overview

After using coding assistants casually for awhile -- think basic inline coding support, suggestions, and we'll call it "super autocomplete" -- I decided to take the plunge and vibe code a project. The results have been mostly impressive with some caveats. I wanted to write this article to gather and document my experiences so far, and lay out my current understanding of what seems to be working well and how to get the agents to do what you think you want.

In short: they are powerful, extremely helpful, and can greatly accelerate your workflow if you constrain them to tight objectives, are very clear about those objectives, enforce quality standards, are willing to review shit, and sometimes wade into the code to fix annoying things.

If left to their own devices -- e.g. if you, the developer are not particularly disciplined in setting up best practices and / or just let them churn with little oversight -- then you can really quickly waste a bunch of compute on garbage results.

This article is a quick context setting and overview of what has worked for me.

2. My Development Stack

• IDE: VSCode
• Agents
  • Github Copilot (in VSCode)
    • was mostly Claude Soonet 4.5 for a bit, now "auto" because they give you a discount
  • Codex (in VSCode)
    • gpt-5.2-codex
    • Mostly used as a planner
  • "Assign to Copilot" feature in Github (whatever they call it)
  • I'll also go research and / or plan shit in Google's notebooklm sometimes or various other tool -- e.g. when I was looking into skills and AGENTS.md files, etc. for VSCode, and when I was brainstorming how to architect my project.
• Agent Support
  • beads (GitHub - steveyegge/beads: Beads - A memory upgrade for your coding agent)
  • OpenSpec kindof (GitHub - Fission-AI/OpenSpec: Spec-driven development (SDD) for AI coding assistants.)
  • I didn't know about these at first, so I actually created a very lightweight agent task tracker to record what my agents were doing / had done for me just based on AGENTS.md instructions, which I'll discuss briefly, which Codex helped me design.
  • AGENTS.md files, various templates (more below), verbose instructions. Need to start leveraging skills, but haven't yet. The Agents created most of this content.
  • Custom MCP server will tool for doing shit locally

3. The Project

Essentially I'm building a suite of agents to help with various life / hobby tasks. The core one is a travel + restaurant agent cluster that helps research and plan trips, and then record details about trips and restaurants that I've visited. Running through this process creates a (knowledge) graph that Agents can use to help me do shit. The goal is to deploy this to Azure at some point and share with alpha-testers / "friends" to see what they think.

Project Tech Stack:

• Python
  • langchain / langgraph for agents
  • lots of fucking pydantic
  • streamlit UI for now; just needed something lightweight
• Neo4j DB
  • ...for everything:
    • coversation history ("short term" memory)
    • user profiles
    • trips, plans, articles, restaurants, attractions, cities, neighborhoods, trip artifacts
    • vector store for vector RAG
    • document hierarchies and links
    • probably other stuff I'm forgetting...
  • AuraDB hosting
    • free tier for now, will see how long that lasts
• OpenAI API to support Agents
• Docker for various components
• Eventually will put in Azure

4. High-Level Takeaways

1. Start with a clear objective
   1. Doesn't have to be perfect, and you'll constantly refine it most likley, but have something clear in mind
   2. Agents love to creep scope, so will run away with your project if you don't constrain it
   3. Create clear, tight ticket for Agents to work; make them plan the work before doing it; review and have them update the plan as needed; encourage clarification questions; take the time to ensure the plan is correct.
2. Templates, Guidelines, Expectations
   1. Create ticket templates / planning templates / document templates - anything you think you'll (i.e. your Agents) be creating a lot of, and that will have some predefined structure, make your Agents co-define and co-design and co-write
   2. Lots of explicit instructions in AGENTS.md, others. My agents didn't like to use beads or OpenSpecat first, so I had to make them write better instructions to use them.
   3. Sometimes you just need to remind your Agents to follow the process that is already defined in the guide files.
   4. If you don't know what to do, just ask your Agents -- they actually for some reason have pretty good ideas for this stuff.
3. Good-ish coding practices / Defensive Coding
   1. Disclaimer: I come from a Data Science / Analytics background, good software engineering practices are not a given in my world, and I feel like people take shortcuts everywhere anyway. You now have an army of Agents now, make them do all the annoying stuff to set up lots of automated shit.
   2. Unit tests (> 90, 95% coverage; you're not fucking writing them, so have at it.)
   3. UAT-esq / integration / E2E / whatever you want to call them that YOU (not your Agents) review that runs through core functionality you expect. Agents will break shit in the persuit of new features if you're not watching carefully.
   4. Pipelines everywhere to make sure shit still builds when the Agents are done. Precommit hooks, branch builds, whatver you can throw at your project. Agents will forget to run tests even if you tell them to, etc., etc.
4. "Done Means Clean"
   1. Make the Agents clean up their garbage. Even when they have beads, crap will still accumulate, you will still find markdown files god know where, etc. I've managed to mostly teach my tools to finish their brainstorming or ticket creating sessions with a cleanup phase, otherwise you will end up with *.md, *.py files in random places that are not actually part of your codebase that will confuse the shit out of you.
5. Review, Refactor, Rebuild
   1. You can iterate a lot for really cheap -- do it!
   2. You cannot / will not be able to diligently review everything once you start moving at any sort of speed, so you need to embrace tearing things down, deleting stuff you don't want anymore, redesigning, etc. often.
   3. Accept that the Agent creating something from a ticket isn't going to get it 100% or even 90%. Have it do the bulk setup, then use a tighter review - Agent update - feedback loop to get it the rest of the way.