The Project
The application let the sales team receive notifications and chat from their phones while they worked away from their desks. It was a React Native app on top of a backend that already existed, so my job was to consume its APIs and turn them into a complete mobile experience. I worked on it from September to December 2025.
It was a real product, with authentication, a chat list, chat conversations, notifications, settings, and all the supporting states that hold those features together.
Learning by Building
I had to learn how React Native handles navigation, component state, API requests, and device behavior while I kept building the product.
Copilot shortened the distance between a question and working code. I described what I wanted, reviewed what it generated, ran it, and asked for changes when the result did not fit the app.
When I hit an unfamiliar React Native pattern, it gave me a starting point I could study inside a real feature. That taught me more than isolated examples would have.
What Changed from the Web
My Next.js and React experience still helped, but mobile came with its own constraints. Screens have different lifecycles than web pages. The on-screen keyboard pushes layouts around. Connections drop. Notifications have to behave correctly whether the app is open, in the background, or being reopened.
Copilot sped up the implementation, and the app itself taught me which of these details needed the most attention.
What I Built
I used Copilot across the whole application. It helped me create and refine:
- Login: connecting the mobile interface to the existing authentication API, with loading, success, and error states.
- Chat list: showing conversations so the most relevant information is easy to scan.
- Chat detail: reading messages, sending replies, and moving through an active conversation.
- Notifications: bringing sales users back to the conversations that needed their attention.
- Settings and supporting screens: the parts that make an app feel finished.
How I Used Copilot
Copilot could write code, but what mattered more was that I rarely had to leave the editor. I used it to draft components, connect API responses to the interface, investigate errors, refactor repeated logic, and try alternative solutions.
Iterating on the Result
The app kept changing from September to December 2025. The first version of a screen was only a start. I kept improving the experience, fixing interactions that felt awkward on a phone, cutting unnecessary work, and looking for places where the app could respond faster and more reliably.
Copilot helped most during these rounds. Once a feature worked, I could ask it to look at the implementation, suggest a cleaner structure, remove duplication, and point out possible performance problems. I still had to test the behavior and decide whether each suggestion made sense, but I could try more improvements in the same amount of time.
From Premium Requests to AI Credits
The way Copilot measures usage changed a lot between the time I built this app and a year later.
| Period | How usage was measured | My experience |
|---|---|---|
| 2025 | A monthly premium-request allowance | Often ended the month with around 60–75% still remaining |
| September 2026 | AI credits, based on the model and tokens used | One sustained day of agent work could use roughly 80% or more of the monthly allowance |
In 2025 the allowance felt almost unlimited. I kept Copilot involved all day, including with Claude Sonnet models, and it felt like a coding partner that was always there rather than something I saved for hard problems.
By September 2026, GitHub had moved eligible Copilot usage to AI credits. My own usage dashboard showed that one sustained day of agent work could leave only 0–20% of the monthly allowance. Those percentages are from my account, not universal limits, but they mean I now have to think much harder about the cost of a long agent session. That is part of why I started trying other tools, which I write about in Working with GPT.
Speed Is Not Understanding
The agent did not remove the need to understand the application. Generated code could be incomplete, assume the wrong thing about an API, or solve a problem in a way that did not fit the experience I wanted. I still read the code, connected it to the existing backend, tested it on a real device, and took responsibility for how it behaved.
The feedback loop got faster. I reached a first implementation quickly and spent the saved time evaluating it, which is how I learned React Native: by building, debugging, and improving a real product.
Lessons
Learn inside a real feature
Studying a pattern in a screen I needed taught me more than isolated examples.
Review every result
Generated code is a starting point. Reading it, testing it on a real device, and owning the final behavior are still the developer’s job.
The first version is only the beginning
Most of the value came from iterating on screens that already worked.
By December 2025 I had shipped a complete set of mobile chat features and iterated on their experience and performance. Copilot did not build the app on its own. It let me learn faster, write more, and go through more rounds of improvement, and for me that is the most useful thing a coding agent does.