What I Learned Building 17 Apps and 3 Web Services: I Had to Protect My Working Memory
A look back at the cognitive discontinuity and working-memory overload from building 17 apps and 3 web services, and how to shrink and resume work context instead of adding tools.
Joohwan Yu · Founder, Full Stack Developer
Toris · Published
Contents
The biggest problem I felt while building 17 apps and 3 web services was not the amount of code. It was cognitive discontinuity and working-memory overload.
As the projects multiplied, I was not simply managing more repositories. I had to hold different run commands, deployment methods, account states, user flows, and unresolved decisions in my head at once. When I moved to an outage or a launch request on another service before I had even written down why I was stuck on one project, I had to recover the context before the code when I came back.
As the numbers grew, what got harder wasn’t implementation
At first I thought that building many products would raise efficiency because I could reuse similar features. In practice, shared components and deployment scripts did cut down repetitive work. But even as reusable code grew, questions that change from project to project remained.
- What is this service’s current deployment state
- How far did I verify last time
- Is the error I’m looking at a code problem or an external service problem
- What is the first thing to do when I come back next time
If this information isn’t gathered on one screen or in one document, it takes time to restart work. Being able to open a repository and being able to resume work right away were different problems.
Cognitive discontinuity came from small moves
Cognitive discontinuity didn’t come only from one big outage. It built up more when short moves like the following repeated.
Fix the mobile app → check the web service deployment → check API logs → check another app's store status
Each task wasn’t hard on its own. The problem was that every move forced me to swap the execution model in my head. Some projects start with a pnpm command, and others needed a different workspace or a separate runtime. On one side the result shows only after users update, and on the other it’s reflected on the next request right after deployment.
While I was remembering these differences, I had less room to think about the actual feature. It wasn’t that the developer’s focus was lacking. The system kept demanding switches.
What working memory had to carry
Working-memory overload was more concrete than saying “there’s a lot to do.” I had to hold the following items at once.
| What I had to remember | The problem if I lost it |
|---|---|
| Current project and working branch | Edit the wrong repository or have to find the change location again |
| Last verified scope | Mistake unfinished work for done |
| Running servers and environment variables | Start a process that’s already running again, or check the wrong environment |
| Deployment timing of app, web, and API | Confuse the latest code with the version users see |
| Next action and deferred decisions | Repeat the same exploration and make the decision again |
Especially when developing with agents, I had to reread “what actually changed and what I verified” rather than “what I asked for.” Even if generation is fast, if the context to review is scattered, the whole job doesn’t get faster.
What I actually tried to reduce was the number of switches, not the number of tools
If you keep adding new tools to solve the problem, it looks easier at first. But when each tool has a different project list, session state, shortcuts, and storage method, it creates another learning cost.
So I changed the criteria. Rather than “can this tool do more?”, I asked the following first.
- Can I see the current state right away when I start work
- Does the flow of reading and editing code myself stay unbroken
- Can I leave the next action when I stop
- Is it easy to recover context when I go to another project and come back
- Is minimal checking and resuming possible from mobile or a remote environment too
These criteria carried over when I later compared AI development tools. As I laid out in why I look at the feature that closes a project, the cost of starting, reviewing, stopping, and returning lasted longer than the impression of the generation screen.
Operating rules that make work context small
I didn’t try to build a perfect memory system. I chose to reduce the amount I have to remember.
1. Leave each project’s current state in one sentence
“In development” is not a state. The next action should be visible, as in “The login callback is implemented, and only the case of re-entering with an existing account isn’t verified.” I update this sentence before closing a session.
2. Put changes and verification in the same record
A record that a file was edited is not enough. I have to leave together the commands I ran, the screens I checked, and the paths I haven’t verified yet, so that the me in the next session, not just the next person, can trust it.
3. Limit the number of projects I look at deeply at once
Keeping every project open all the time may not be parallelism but a growing number of open loops. Separating read-only checks from actual change work and reducing the number of projects I edit deeply at a time helped me protect focus.
4. Separate common rules from project rules
I don’t mix principles needed for all work with commands needed only in a particular repository in one document. I keep common guidance short and keep deployment, testing, and domain rules close to the project. That way I can bring in only the context I need.
The ability to re-enter, more than the ability to build a lot
The numbers 17 apps and 3 web services show what I built, but they don’t guarantee a sustainable way of developing. As products multiply, what matters is not the ability to remember more work but the ability to build a structure where I can start again without having to remember.
The condition I now care about most in a development environment is not flashy features. It is whether I have less context to recover when I start work, can clearly see the scope of changes when I review, can leave the next action when I stop, and can carry minimal state over on another device.
In the end, raising productivity was not about putting more projects in my head. It was closer to taking out of my head, and into the system, the things that don’t need to be kept there.
Advertisement