Published: December 30, 2025
Building with Copilot
In September 2025, I started using GitHub Copilot more seriously as a coding agent. I was already developing several Next.js projects, but at the same time I was learning React Native and building a mobile application for internal use at my company. The application was made for the sales team to receive notifications and communicate through chat while working from their phones.
The backend was already available, so my responsibility was to consume its APIs and turn them into a complete mobile experience. GitHub Copilot became one of the main tools that helped me move from understanding React Native concepts to delivering features that people could actually use.
Learning React Native while building a real application
This was not a small practice project. The application needed authentication, a chat list, detailed chat conversations, notifications, settings, and the supporting states that connect those features. I had to learn how React Native handled navigation, component state, API requests, device behavior, and the differences between mobile and the web while continuing to build the product.
Copilot helped shorten the distance between a question and a working implementation. I could describe what I wanted to build, review the generated code, run it, and then ask for changes when the result did not fit the application. When I encountered an unfamiliar React Native pattern, it gave me a practical starting point that I could study in the context of a real feature instead of learning everything only through isolated examples.
My experience with Next.js and React still mattered, but mobile development introduced new constraints. Screens have different lifecycles, keyboards affect layouts, network connections are not always stable, and notifications must behave correctly when the application is active, in the background, or reopened. Copilot accelerated the implementation, while the application itself taught me which details required more attention.
From generated code to a complete mobile experience
I used Copilot across the application rather than for one isolated feature. It helped me create and refine:
- Login flows that connected the mobile interface to the existing authentication API and handled loading, success, and error states.
- Chat lists that presented conversations clearly and kept the most relevant information easy to scan.
- Chat details where users could read messages, send replies, and move naturally through an active conversation.
- Notifications that brought sales users back to the information and conversations that needed their attention.
- Settings and supporting screens that made the application feel complete instead of like a collection of disconnected features.
The useful part was not simply that Copilot could produce code. It helped maintain momentum. I could use it to draft components, connect API responses, investigate errors, refactor repeated logic, and explore alternative solutions without leaving the development flow every few minutes.
Iteration mattered more than the first result
From September to December 2025, the application continued to evolve. Shipping the first version of a screen was only the beginning. I repeatedly improved the user experience, adjusted interactions that felt awkward on a phone, reduced unnecessary work, and looked for places where the application could respond faster and more reliably.
Copilot was especially valuable during these iterations. Once a feature worked, I could use it to examine the implementation, suggest cleaner structures, reduce duplication, and help identify possible performance problems. I still needed to test the behavior and decide whether a suggestion was appropriate, but I could explore more improvements in the same amount of time.
In 2025, Copilot's monthly premium-request allowance felt almost unrestricted in practice. I could keep it involved throughout the day, including when working with Claude Sonnet models, and often reached the end of the month with around 60-75% of the allowance still remaining. It felt less like a tool reserved for difficult moments and more like a coding partner that was continuously available while I built and learned.
By September 2026, the experience felt very different. GitHub had moved eligible Copilot usage to AI credits, with consumption based on the model and the number of tokens used during an interaction. In my own usage dashboard, one sustained day of agent work could consume roughly 80% or more of the monthly allowance, sometimes leaving only 0-20%. These percentages are not universal limits, but they show how much more carefully I now have to think about the cost of long agent sessions.
Acceleration does not replace understanding
Using a coding agent did not remove the need to understand the application. Generated code could be incomplete, use the wrong assumption about an API, or solve a problem in a way that did not match the experience I wanted. I still had to read the code, connect it to the existing backend, test it on a real device, and take responsibility for the final behavior.
What changed was the speed of the feedback loop. Instead of spending too much time getting from an idea to the first implementation, I could reach that point quickly and spend more time evaluating the result. That helped me learn React Native through building, debugging, and improving a real product.
By December 2025, I had developed a complete set of mobile chat features and iterated on their user experience and performance. GitHub Copilot did not build the application on its own, but it gave me leverage: I could learn faster, produce more, and improve the work through more frequent iterations. For me, that is the most useful role of a coding agent, not replacing the developer, but accelerating the path from learning to delivering.