In the summer of 2023, I asked ChatGPT to help me write a piece of MicroPython code. It ran on an ESP32, reading the temperature, humidity, and air quality at home every few minutes and sending the data to a Raspberry Pi.
Three years later, this unassuming little device is still running, and the database has accumulated more than 270,000 records.
At the same time, the way I use AI has changed completely. Now, on my way to work, I take out my phone and hand a requirement to Codex. It reads the code, edits files, opens a Pull Request, and then GitHub deploys it automatically. Quite often, a new feature is already live before I get to the office.
From web chat to Copilot and then to AI Agents that can execute tasks independently, I have experienced three very different ways of working together. Looking back and putting everything in order, I realized that the first short script had gradually grown into sensors, a mini-program, a live photo platform, a podcast, a wedding website, AI videos, and 3D models.
This article is an attempt to record all of them in full.
The Three Stages of AI Programming
ChatGPT was publicly released on November 30, 2022. At the time, the most common entry point was a web chat box: type in a question, wait for an answer, and then copy the result into another tool.
The Copilot form appeared earlier. GitHub Copilot opened for technical preview in 2021, but I did not truly feel AI entering the development environment until I started using Cursor in April 2025. AI could see more project files, and it could continuously modify scripts that called one another.
In 2025, programming Agents began appearing in rapid succession: Claude Code opened for research preview in February, Codex CLI launched in April, and the Codex cloud Agent was released in May. AI began reading entire repositories, running commands and tests, and participating directly in GitHub workflows.
These three stages have always overlapped. The division below is based on how I mainly used AI at the time:
Web chat stage: I described the problem, AI generated a script, and I copied, ran, and debugged it.
Copilot stage: AI entered the editor, understood the project context, and helped modify multiple files.
Agent stage: I stated the goal, AI called tools, executed tasks, submitted code, and handed the result back to me for inspection.
Interestingly, I stayed in each stage for less time than in the previous one, while the projects I could complete became longer and longer.
Stage One: A Program Written in a Chat Box That Really Ran for Three Years
When I first started using ChatGPT, I quickly found that it was very good at writing scripts. The models at the time were difficult to control for large software projects, but they could already provide a great deal of help with clear, limited programs such as MicroPython. I was experimenting with an ESP32, so I asked ChatGPT to help develop a home environment monitoring system.
My First Long-Running AI Project
The project began running in June 2023.
The ESP32 connects to BME280 and SGP30 sensors to collect temperature, humidity, air pressure, TVOC, and eCO₂ readings. The data is written to an SQLite database and visualized through Superset on a Raspberry Pi. ChatGPT also helped me work out the architecture, draw diagrams, and write the technical documentation.
By April 2026, the database had accumulated 271,142 sensor records.
These data record the seasonal changes inside a Beijing home: humidity rises in summer, the air becomes noticeably drier after heating starts in winter, and readings rise when ventilation decreases at night. The CO₂ data reported by the SGP30 are algorithmic estimates and are easily affected by TVOC, so they are better suited to observing trends. This limitation also gradually taught me that AI can generate an analysis quickly, but the sensor principles and the boundaries of the data still require human judgment.
The value of running continuously for three years far exceeds those first few lines of code. It left behind a real, continuous record of my own life, and changed the way I think about personal projects: once a program truly enters everyday life, even a very small idea can accumulate results that are hard to anticipate.
Following that line of thought, I began connecting ChatGPT to more everyday tools.
A WeChat Bot Without Hooks
At the time, I found conversations with a large language model much more interesting than traditional rule-based bots, so I tried connecting one to WeChat.
The usual approach required reading WeChat messages through low-level hooks. Concerned about account security, I chose a more conservative route: the program simulated mouse clicks, used OCR to recognize chat content on the screen, and then called the model to generate a reply.
It could only handle one-to-one chats, and it was hardly fast, but it completed the loop from “seeing a message on the screen” to “automatically giving an answer.” This was the first time I had connected a large language model to an everyday communication tool.
A Short-Link Platform Running on Lambda
I also used ChatGPT to build my own short-link service. Enter a very short path, and it takes you to a website I use frequently.
The service runs on AWS Lambda. It is tiny and costs very little to maintain. It had no grand product plan; it only solved a small nuisance I encountered every day. Later, I came to like this kind of project more and more: meet your own needs first, and then see how far it can go.
Stage Two: AI Enters the Editor and Scripts Begin Connecting into Systems
During the web chat stage, code usually appeared in fragments. I had to copy and paste repeatedly to connect different scripts. Once AI entered the editor, it could inspect the project structure, understand how files called one another, and make continuous changes around the same goal. The scale of the projects grew with it.
A Mini-Program to Assist with Time-Lapse Photography
The “Time-Lapse Photography Calculator” went online in June 2024.
It helps photography enthusiasts calculate what they need based on the shooting interval, the number of source images, and the target video length. After I entered the Cursor stage, I continued to maintain and iterate on it with AI. By July 2026, the mini-program had about 1,700 users.
That number is tiny by the standards of an internet product, but it means a great deal for a personal project. A tool that began with a personal need was still being used two years after launch, and was still worth maintaining.
A Very Low-Cost Live Photo Platform
When I began using Cursor, what I wanted to build quickly expanded from a single interface into an entire workflow. Live photography is already common at conferences, competitions, and large events. Commercial solutions often charge by event or require an annual subscription, so I used Cursor to build my own implementation.
After the camera takes a photo, it is sent in real time over the local network to an FTP server. When the server detects a new photo, it uploads it automatically to Alibaba Cloud OSS and generates a photo index file. The front end only needs a static HTML file; after reading the index, it can keep displaying the latest photos.
Shared links also have an expiration time and can be taken offline automatically when they expire. The whole system relies mainly on OSS, static pages, and a few automation scripts. By using the free storage and bandwidth quotas provided by the cloud platform, the actual cost is almost negligible.
In the past, a program spanning devices and services like this required considerable time to handle the details. Cursor let me describe the complete workflow first and then inspect each part step by step.
Using 14,000 Photos to Observe the Neighborhood Morning Rush
During the same period, I also became increasingly willing to connect programs to the real world. In the spring of 2025, I conducted a small curiosity-driven study.
One morning, I noticed that there seemed to be very few pedestrians on the main road through the neighborhood. I wanted to know: What time do residents usually leave home? How are weekdays different from weekends? When do people walk their dogs?
I placed a Raspberry Pi, an HQ Camera, and a 25mm lens on the windowsill, taking a photo covering the neighborhood’s main road every 10 seconds. The Raspberry Pi handled collection, and the images were sent over the local network to a Mac mini. After cropping the frames, the Mac used YOLOv12x to identify people, dogs, and bicycles, wrote the times and counts to SQLite, and finally imported the data into Superset for analysis.
The system processed about 14,000 images in total. The preliminary results showed that 8–9 a.m. and 5–7 p.m. were the pedestrian peaks on weekdays; activity was more evenly distributed on weekends; weekday dog walking clustered around 8 a.m., while on weekends it was spread throughout the day.
The experiment also left many problems: the images were too dark at night, the same person could be counted repeatedly across multiple frames, and distant subjects lacked enough distinguishing features. Manual sampling showed that the counts were roughly twice the actual number.
These flaws did not make the experiment worthless. It showed me that a small system made up of a Raspberry Pi, a local model, and a database could already turn a question from everyday life into analyzable data. Looking back, the most important change of the second stage happened here: AI began helping me bridge the gaps between files, devices, and cloud services, and a one-person project began to take the shape of a complete product.
Stage Three: From Helping Me Write Code to Taking Over an Entire Workflow
After 2025, I began using AI Agents frequently. The clearest change in this stage was the length of the tasks. In the past I asked AI to write a function; later I asked it to complete a page; now I hand it “build a system that can run, be published, and be maintained over the long term.”
A Wedding Website Built on a Phone
This change became especially clear while I was preparing for my wedding. After December 2025, I used Codex to create a complete wedding website, and the interactive games at the ceremony, such as quizzes and raffles, were also completed by an AI Agent.
After the wedding, the site continued evolving into a family website for recording anniversaries, experiences from daily life, and our pets.
The entire project was developed by Codex, built through GitHub CI/CD, and published automatically to Alibaba Cloud OSS and CDN. I did not type the code by hand. Much of the development happened on my way to and from work: I took out my phone and described a requirement, Codex modified the code and opened a Pull Request, I checked the result and merged it, and the site was deployed immediately.
The phone had become the project command center. The uninterrupted time needed to write code was greatly reduced, and scattered moments during the commute could also move the project forward.
A Podcast That Updates Automatically at 7 a.m. Every Workday
In fact, earlier, in June 2025, an Agent had already begun taking over tasks that needed to run on schedule every day. I launched the fully automated cybersecurity podcast Security Fresh News. Every day, the system pulls news from the RSS feeds of cybersecurity media and writes it to an SQLite database. Multiple agents on Alibaba Cloud’s Bailian platform then divide up the work of summarizing the news, drafting the script, reviewing the content, correcting pronunciation, and producing the program title and Show Notes.
Pronunciation processing is a very concrete step. For example, the system converts “Pwn2Own” to “Pwn To Own,” changes “SQLI” to “SQL injection” in Chinese, and rewrites “ATT&CK” as “attack” so that it can be read properly by TTS. Once processing is complete, Alibaba Cloud TTS generates the audio; a program joins the opening and closing segments, then uploads the files and Podcast Feed to OSS and publishes them through the CDN to Apple Podcasts and Xiaoyuzhou.
A scheduler executes the entire process automatically, and exceptions are pushed to my iPhone. The show has continued updating since launch and is published promptly at 7 a.m. every workday. So, on the subway to work, I can listen to a news program that was automatically produced just that morning.
Automatically Check the Weather and Send Clothing Advice to WeChat
Also in June 2025, I used Alibaba Cloud Bailian to build a weather reminder assistant. Every day it checks the weather and alert information, generates clothing advice based on temperature, precipitation, and wind, and sends the result to WeChat. The podcast and weather reminder were the first time I had two systems that could wake up, do their work, and proactively find me on their own.
After completing these long-running projects, I brought Agents into content creation as well.
Rewriting the Day’s Diary as a Story Set in 2065
I have used Codex to build an article-generation and publishing system.
Every day, I only need to write down a simple record of life. The Agent extracts the content according to a preset Markdown structure, maps a real day into the year 2065, and rewrites it as a short diary entry with a futuristic technological setting.
For example, a real-world autonomous car becomes a “private intelligent warehouse,” and an ordinary theater becomes an art center using low-density light-field scenery. The details of daily life still come from things that actually happened that day.
The column ran for only three days. The reason was straightforward: it received very little traffic, so I stopped updating it.
AI makes content production very fast, but whether readers want to read it still depends on the topic, the expression, and how it is distributed. An experiment with no traffic can still leave behind a useful conclusion.
Handing the Pre-Production Work for AI Videos to an Agent
Generating a single AI video is not difficult. The time-consuming part is the preparation: expanding the script, breaking it into shots, making reference images, designing the first and last frames, and then writing separate prompts for the images, video, and music.
My approach is to provide only the idea and a short script, then have Codex complete the detailed storyboard and organize the subsequent generation workflow through the relevant LibTV Skill: preparing reference images, opening and closing images, image prompts, and video prompts for each segment, and then calling the generation tools to make the video clips.
I still complete the final edit in the traditional way. Shot rhythm, emotional control, and the selection of material require a great deal of personal judgment, while AI takes on the repetitive and tedious pre-production work. I also let AI generate the music prompts, and the finished piece turned out more complete than I had initially imagined.
From a Description to a 3D Model You Can Print
After video, I extended this path into 3D design. One project was a storage box for square Polaroid film: GPT-5.1 generated OpenSCAD code, which was then converted into a 3D-printable model. The lettering on the lid could be modified through parameters, and the final version could hold about 50 sheets of Instax Square film.
Code, models, and physical objects came together here. The output from AI left the screen and became something I could actually hold in my hand. By this stage, it had become difficult to describe what I was doing simply as “writing code.” It was more like mobilizing code, models, and various tools to push an idea all the way to something usable, listenable, watchable, or even touchable.
Three Stages, Changing the Distance Between Me and Software
Looking back at these projects, each of the three stages had its own characteristic action.
In the web chat stage, I kept copying code, running it, and pasting errors back into the chat box.
In the Copilot stage, AI and I faced a project together. It understood the context; I decided the structure and direction.
In the Agent stage, I began describing the goal, constraints, and acceptance criteria, and let AI handle much of the work in between.
AI certainly did not make every project successful. The neighborhood foot-traffic experiment had duplicate counts, the SGP30 could not provide an accurate CO₂ concentration, the “future diary” had no traffic, and AI videos still required careful manual editing. Real projects always run with limitations.
But it did shorten the distance between an idea and a finished product.
Three years ago, a piece of MicroPython code delighted me. Today, I am used to managing, from my phone, Agents that read code, run tools, and submit PRs on their own. The next step might be more complex 3D design, longer video-production workflows, or a group of Agents working at the same time.
I still do not know what I will make.
The good thing is that now, when an idea appears, I can start working on it immediately.