I started using PyCharm IDE back in 2019 for my work, and I’ve been hooked on it ever since. Since then, I’ve explored other AI-powered IDEs like Cursor and Windsurf, actively experimenting with each new release to see what they offer.

At PyCon US this year, I got to meet the JetBrains PyCharm team in person. They gave me a quick demo of Junie, and I knew immediately I wanted to give it a shot.

Below, I’ll share the detailed steps I took while developing Pyzlides, along with a few tips on making the most of AI-assisted coding.

Initial Setup

For AI coding tools, context is the most important. I always spend lot of time to create the initial prompt which will be given to the agent. I try to make it as detailed as possible with examples and intended usage. Initially, I bootstrapped the environment using uv and installed the dependencies in the environment. After a bit of brainstorming and help from ChatGPT to decide the project dependencies, I decided to use the below dependencies:

• ReportLab: For generating the PDF slides.
• Pillow: For handling images in slides.
• PyYAML: For parsing the configuration file.

I installed these libraries in the environment and this was my major point of contribution. After this point, the entire building was done by Junie and I was only involved with writing prompts.

Getting started with Junie

I used the Junie premium subscription for this project. Below is a screenshot of Junie’s chat interface:

Junie provides a simple, familiar chat interface to interact with. From the interface, we have two conversation modes:

1. Code mode: Junie directly generates or edits code.

2. Ask mode: Useful for discussing the codebase, understanding unfamiliar code structure, or clarifying doubts without making direct code changes.

Additionally, using the + button, we can attach relevant files to give Junie more context about the project.

Junie includes a Brave Mode toggle. When enabled, Junie executes terminal commands (such as creating directories, running the project, etc.) without asking for user confirmation. I recommend using Brave Mode only with simpler projects where you fully understand and trust the codebase. Otherwise, it poses a risk of unintended actions or prompt injection.

Recent Junie versions introduced another toggle: Think More, prompting the AI model to reflect more carefully during code generation, improving the overall quality of its responses.

Setting context

As we’ve previously discussed, AI coding assistants perform best when given ample context. Junie provides helpful ways to ensure it understands our project’s codebase clearly:

• .aiignore: From the + menu, we can generate an AI-ignore file, similar to .gitignore. Files added here won’t be modified by Junie.

• Guidelines: Also available through the + button and example prompts are project-specific instructions. Junie uses these as guidelines to stay aligned with project conventions. I will share the guidelines I created later in this post.

Junie Settings

Before we dive deeper into Pyzlides, let’s quickly look at Junie’s settings:

• Models:
  I chose Claude Sonnet 4 as my model, as it’s currently one of the best for coding tasks.

• Connect MCP Servers:
  MCP servers allow Junie to interact with external resources. They can be configured globally in settings or specifically for a project by adding them to the /.junie/mcp directory in the project’s root folder.
  For instance, if we integrate Stripe, connecting the Stripe MCP server ensures Junie understands and accurately utilizes Stripe’s latest API operations, significantly improving the quality of generated code.

• Action Allowlist:
  Here, we can specify terminal commands Junie may run directly without asking for our confirmation.

Init Pyzlides

To help Junie understand the project clearly, I prepared an initial prompt using ChatGPT. The complete prompt is available in the Pyzlides repo here.

Here’s a brief version of the initial prompt:

Pyzlides: Python Presentation Creator

Overview

Pyzlides is a Python library that lets us create PDF presentation slides directly from Python code. Slides are generated in standard presentation resolution, and elements like headers, body text, images, and layouts can be defined using simple Python classes. Pyzlides supports custom themes, layouts, and ordering slides through a configuration file.

Features

1. Declarative Slide Creation: Define slides using Python classes like Head1, BodyText, Img, etc.
2. Custom Layouts: Use custom layouts like Center or Bottom for positioning elements.
3. Configurable Themes: Define themes such as colors, fonts, and backgrounds via a config file.
4. Slide Ordering: Specify slide sequence in the configuration file.
5. PDF Output: Generate presentations as PDF files.
6. Extendable: Easily extend slide functionality by creating new element types or layouts.

---

Dependencies

• ReportLab: PDF slide generation.
• Pillow: Image handling.
• PyYAML: Config file parsing.

Core Classes

1. Base Slide Element Classes

   • Head1(text: str): Large header text.

   • BodyText(text: str): Paragraph-style text.

   • Img(path: str, caption: str): Image with optional caption.

   • Bold(text: str): Bold formatting.

   • Center(element): Center-align element.

   • Bottom(element): Bottom-align element.

To begin, I clicked on the example prompt button in Junie to generate project instructions. Junie created detailed guidelines automatically and stored them in the .junie directory. This file includes key features, project structure, and expectations. You can view it here.

Start Coding

One aspect I liked about Junie was its ability to first generate a clear implementation plan before writing any code. This made complex tasks manageable and easy to review.

Once Junie starts, it updates progress as each step completes. Below you can see Junie’s initial implementation plan for Pyzlides.

Below is the expanded interface when the task was completed by Junie. The pane on the right shows the steps taken for the implementation.

After finishing a task, Junie suggests helpful follow-up actions like adding files to Git or reverting unwanted changes.

The initial implementation by Junie was already impressive. There were minor alignment issues, so I asked Junie to fix these in the next prompt:

the pages are made in portrait mode - change it to landscape mode.

also, bolding does not seem to work.

increase the text size - it is a presentation, not just a simple pdf file.

also make necessary changes so that this can be published as a library. people can install this library and then add config and slide files and use the lib to generate pdf. sample slide files and config can be moved to examples folder if needed. keep the library source directory clean

Once fixed, I asked Junie to add more advanced features and create example slides to showcase Pyzlides capabilities clearly:

create multiple elements to support:

title slide - just a title in the centre - horizontally and vertically

image backgrounds - support images as slide backgrounds.

fix text getting cut out to the next sections.

add H1 to h3 tags - different type of sections.

in the example presentation, add slides to illustrate various types - title only, title with text, title with image, title with image and text, dark mode presentation, white mode presentation, custom background image presentation.

make folders inside example folder for each example. add more elements to the definition as needed - to support a fully featured slides functionality.

also, inline text colours can be specified to text elements.

After this, I asked Junie to add features like code snippets and grid layouts. After these enhancements, the library was nearly complete.

Finishing Up

There were a few remaining issues, primarily with text overflowing slides. I prompted Junie to handle these scenarios clearly:

1. detect when texts flow out of the view - and then fix it to go to next line. regenerate all examples after this change. also test this with long headings, text, etc. there should be a bit of default margins on top botoom left and right.

2. also, add a code component - that accept a code in markdown block and provide syntax highlighted output in text. you can use the already installed pygments library for the same.

Next, I asked Junie to address a few bugs from previous implementations:

• syntax highlight is not working.
• when there is too much text, split it into multiple slides automatically. currently the contents are being cut out - for example in the text and code example.
• also the newline feature is not working as expected. since title texts are starting from centre of the page, some text is still getting cut out horizontally - relook the calculation part

Throughout this project, I enabled Brave Mode. This allowed Junie to automatically run example code, generate PDFs, and proactively identify and fix issues.

To make Pyzlides easy for new users, I also had Junie add a README to guide them through using the library. At this stage, I noticed an unused layout section in the config files. I asked Junie to remove this:

i can see that the layouts section in config is unused. remove this from example config files and Config class defined in core

Junie’s response was prompt and accurate:

The layouts section was removed from the Config class in core.py and from all example config files, confirming it was unused. Functionality was verified by successfully generating presentations from both the basic-presentation and grid-layout examples without any errors.

Summary

The entire Pyzlides project—including fixes and improvements—was completed with fewer than 10 prompts. Below is the final file structure:

project_root/
├── .gitignore
├── pyproject.toml
├── pyzlides.py
├── readme.md
├── uv.lock
│
├── .junie/
│   └── guidelines.md
│
├── pyzlides/
│   ├── __init__.py
│   ├── __main__.py
│   ├── cli.py
│   └── core.py   # Core library functionality (1010 lines)
│
└── examples/
    ├── README.md
    │
    ├── images/
    │   ├── bg_black1.jpg
    │   ...
    │
    ├── basic-presentation/
    │   ...

These are the core files of the library:

• pyzlides.py: Main command-line entry point for generating presentations.

• pyzlides/

  • cli.py: Handles command-line interface functionality.
  • core.py: Contains the core implementation and logic of Pyzlides. Includes the component definitions, parsing logic and pdf generation code.

My conclusion: I’m impressed with Junie - especially loved the planning mode. Few would guess an AI coding agent could accomplish such a detailed task within minutes.

I haven’t fully refined or battle-tested Pyzlides yet, but it’s already an excellent starting point. You can review the generated PDFs in the examples folder, and see for yourself :)

Notes for AI-Assisted Coding

• Use Brave Mode cautiously, especially in complex or sensitive projects.
• Provide clear, detailed context for the best results.
• Always verify the plan generated by the agent and course correct whenever needed.
• Consider tools like GitIngest to enhance context. Also, connect MCP servers when available for deeper integrations.

Links

• Pyzlides GitHub project: GitHub - adarshdigievo/pyzlides

• Junie Docs: Junie, the AI coding agent by JetBrains

• Junie Playbook: PyCharm Junie Playbook - JetBrains Guide

• Download Pycharm : PyCharm: The only Python IDE you need

I’d like to thank the JetBrains team for collaborating on this project. I look forward to using Junie in future experiments.

At this PyCon, I decided to try something different. I skipped most of the talks and focused on the hallway track - just walking around, meeting people, and asking questions.

I was also presenting a poster at PyCon - on using Python to improve at chess: presentation materials here.

Before the conference, I had prepared a few questions I wanted to ask the Python people:

• What do you think is the future of programming?

• Will AI take over programming jobs in the next 2–3 years?

• What AI tools do you use in your daily work?

• What advice do you have for Python developers?

Most of the people I talked to are familiar names in the Python community. I’ve read their blog posts, watched their talks, or used their open-source tools. There were many more people I wish I had a chance to talk to, but I’m glad I got to speak with the ones I did.

One thing surprised me - very few people said AI will replace developers. I expected more.

Later I realized why. Most of the folks I spoke to are working on deep, core programming problems - like optimizing CPython, or building dev tools. These are areas where current AI tools aren’t that useful. LLMs haven’t seen much of that code. So maybe it’s not that surprising after all.

Here’s what they said:

Guido van Rossum — Dutch programmer

Guido said AI won’t replace programmers.

He’s not a fan of “vibe coding” (letting AI write code you don’t understand). He is not impressed with the quality of the code generated by current tools. But he does use GitHub Copilot (for autocomplete) and he expects AI assistants to get much better in the future - something like a supercharged Copilot.

Anthony Shaw — PSF Fellow, Author of CPython Internals

Anthony said AI is like the new Stack Overflow.

Earlier, people copied code from blogs or seniors. Now it’s from ChatGPT.
AI is useful for boilerplate or things you already know. He uses Copilot Chat for regular stuff and agent mode when he’s working on something unfamiliar (like frontend work).

His advice: Don’t blindly rely on AI. If you don’t keep learning, the gap between juniors and seniors will grow fast.

Anthony's Website · My favorite project – VSCode Pets

Anthony Sottile - Maintainer of pre-commit, flake8, and pytest

He doesn’t use AI tools.

He said his problems are too complex for AI. It’s easier for him to just write the code than explain it to a chatbot.

He does agree that AI is good for boring or repetitive code.

Anthony's GitHub · YouTube – Anthony Writes Code

Reuven M. Lerner - Python Author & Trainer

Reuven said companies should not replace junior devs.

He said juniors are like seeds. If companies don’t invest in them now, they’ll struggle later when they only have senior devs and AI bots.

He uses AI mostly for writing—like reviewing posts or generating images. He rarely uses it for coding.

Reuven's Website – lerner.co.il · Great courses and newsletters for Python devs

Trey Hunner — Python Morsels

Trey said AI won’t replace developers.

But it might change how we work.
Developers might end up reading and reviewing more code instead of writing everything from scratch.

He doesn’t use Copilot or coding tools. He copies from ChatGPT when needed and uses a tool called Typingmind to talk to AI.

Trey's Website · Python Morsels

It is also worth a mention that Trey taught us the Cabo card game during the evenings after PyCon.

Samuel Colvin — Founder of Pydantic

Samuel had a different view.
He said AI will replace some programmers.

Companies will use AI to do more with fewer people.
He sees AI as a way to speed things up and make work more efficient.

He uses tools like trae, cline, and others to boost his workflow.

Samuel's Website · GitHub

Simon Willison — Django co-creator, Creator of Datasette

Simon said AI won’t replace developers. But it will create new types of work and improve productivity.

He uses Claude, ChatGPT, and his own LLM CLI tool.
For personal scripts, he uses AI to get things done quickly, and reviews the code properly when it matters.

Simon's Website · GitHub

Mariatta Wijaya — Python Core Developer

Mariatta said AI is more helpful for senior developers.

Seniors can use AI to write code quickly and then fix what’s wrong.
For juniors, it depends. If the task is small, AI can help. But juniors still need to understand what the code does.

She uses Copilot in her daily work.

She also recommends this talk from PyTexas:
Heather’s Talk – How to Think Like a Senior Engineer

Mariatta's Website · GitHub

Final Thoughts

Most Python people agree: AI won’t replace developers anytime soon.

My thoughts: it will definitely change how we work.

If you’re using AI without understanding, you’ll likely fall behind.
If you keep learning and adapt, you’ll do fine.

My personal favorite moment

One of the highlights of PyCon US for me was meeting Paul Everitt.

He gave me a sneak peek of the Python documentary trailer before it was released on YouTube. And even better—he handed me a chocolate Cornetto from the PyCharm booth while telling stories. Instant core memory.

Paul is one of the most enthusiastic and genuine people I met at the conference. A natural storyteller.

A few things I didn’t know about him until then:

• He managed navy.mil while serving in the U.S. military—one of the earliest websites on the internet.

• He was a keynote speaker at the first-ever Python conference in 1994.

• He helped incorporate the Python Software Foundation.

• He was Guido’s manager during his Plone days.

The kind of person you meet once and never forget.

That’s all from my hallway track this year.