If AI Can Do It All, What Can I Add?
, 16 min, ai, developer, reflection
If AI writes the code, what is my role? Looking back at development work and a one-off demo helped me explore what I need to understand and what I can contribute.
, 16 min, ai, developer, reflection
If AI writes the code, what is my role? Looking back at development work and a one-off demo helped me explore what I need to understand and what I can contribute.
For a while, I couldn't bring myself to read the code Astra had written.
Here is an excerpt of the code Astra wrote at the time.
function Content({ content, evidence }: { content: TestContent; evidence?: (id: string) => void }) {
return <div className="test-content"><h4>사전 조건</h4><ul>{content.preconditions.map((p,i) => <li key={i}>{p}</li>)}</ul><h4>실행 절차</h4><ol>{content.steps.map((s,i) => <li key={i}>{s}</li>)}</ol><h4>기대 결과</h4><p className="expected">{content.expected}</p><h4>근거 구절</h4><div className="evidence-links">{content.evidenceIds.length ? content.evidenceIds.map(id => <button type="button" className="evidence" key={id} onClick={() => evidence?.(id)}>{id}</button>) : <span className="muted">근거 없음, 확인 필요</span>}</div></div>
}
There was so much of it, and I didn't know where to start.
My first thought was, “Can I understand something like this?” That soon led to, “Do I have to understand it?” If I didn't need to, what should a person do? If I did, how much did I need to know?
My first question to AI was about good code. I asked whether the standards for good code stay the same when AI writes it. I also asked whether the ability to write good code myself still matters. But when I thought about why I'd asked, there was a more personal concern behind it.
If I neither write the code nor understand the code that's been written, what am I here for? What is my role?
I discussed this with AI. The exchanges below are shortened and edited versions of the actual conversation. Between them, I've added why I asked the next question and what I understood.
Looking back, I think I also felt frustrated. When I understand the code, I can see where I might judge or check it. But when I can't read it at all, I don't know where or how to offer an opinion.
During the discussion, though, we found a flaw in Astra's code. Two thoughts came to me at once.
Finding a problem didn't immediately tell me what my role was. Whenever I found something I could do, “Couldn't AI do that too?” followed. Thinking about reviewing code instead of writing it didn't change that. Neither did thinking about giving instructions or verifying results.
So I asked more directly.
We searched my personal wiki and the web. Simon Willison had written about similar feelings. There were proposals for people to set the conditions work must meet and decide whether to accept the results. There was also a team describing a development process where people neither write nor review code.
As I read, I started asking, “What is being compared with what?” Suppose an experienced developer and a beginner both use AI. If the experienced developer gets a better result, that experience may have helped.
But I wanted a slightly different comparison. I wanted to compare a person working with AI against delegating that person's work to AI too. The difference between the two developers' results couldn't easily answer that.
UI and animation came to mind. UI means the screens people see and interact with. In the conversation below, a reference is an example showing the kind of screen or movement I want to create.
I didn't always know exactly what I wanted from the start. Sometimes I only thought, “I'd like to go in this direction,” after seeing other screens. Choosing references could itself be how I discovered what I wanted.
I paused there. Looking back over the whole conversation, I noticed something we'd left out.
AI may have reviewed the code. AI may also have found example screens and implemented the design. But before that, someone looked at the result and decided, “This isn't enough; let's try a different approach.” That choice was part of making the result too.
I think I'd been looking for my role only in moments when I changed the code myself. In our conversation, we kept leaving out the choice that came before the work because AI could execute it. If changing the way we worked improved the result, I had contributed something even though AI carried it out.
We hadn't separately tested the effect of a review or a reference search in this conversation. We'd identified changes to try in the way we worked. We still needed to check whether they would help.
That raised the next question. What happens if AI takes over the choices people make today?
AI described a development setup where different AI agents handle planning, implementation, and evaluation. Here, an agent means an AI that takes on and carries out work.
Examples like this suggest that AI could also take over the decision to search for references. I couldn't assume people would keep doing it. But the possibility of automating it later doesn't erase what a person contributes now.
To decide what to learn and how to work, I needed to consider both today and the near future. If something helps now, I have a reason to explore it. I don't have to first prove that it will remain exclusively human forever. But I also need to consider whether it might soon become a standard AI feature.
With those two time frames in mind, we returned to UI.
Whether the features worked properly wasn't my only concern. I was also disappointed by how the screens kept looking like something I'd seen before. I thought that even after working screens became easy to build, I might still come to want more from them.
That led to the question, “How much do we need to build before it's finished?”
The percentages here aren't measured scores. I'm calling the level I want today 100%.
If reaching that level becomes easy, I might want to try things I hadn't dared to attempt before. I might seek a different experience because so many screens look alike. Even after I've built everything I want now, I might come to want something new later.
I'm not suggesting that every project should be revised endlessly. I'm thinking that after finishing one thing, I might find something new I want to make. That question hadn't occurred to me when I was only thinking about finding and filling gaps in AI's ability.
At this point in the conversation, I'd arrived at two questions.
Now: What can a person do to bring AI to 100%?
In the future: What can a person do to bring AI to 150%?
I had two questions, but what I was contributing to my own work still felt vague. We continued by looking at recent experiences one at a time.
First, we returned to a horizontal scrolling problem on this blog's mobile layout. I'd found it while viewing the deployed site on my phone.
I hadn't read all the code to find the cause. Noticing the problem on the screen reminded me of an earlier experience. I removed elements one by one to narrow down where it was happening. I passed what I'd found to AI so we could work on the fix.
I looked back at when I'd gained that experience. From 2023 through early 2025, I learned a lot by writing code, logging values to the console, and using browser developer tools. After that, I started asking AI first more often.
AI asked if I'd learned anything since then that I'd used to solve another problem. As I thought about it, I realized that the way I approached problems had changed.
By architecture, I mean how code is divided into responsibilities and how those parts connect. I gave AI both the current structure and the one I wanted to move toward. I asked AI to refer to both documents when building the feature. I hadn't measured the effect, but I could describe how I'd changed the way we worked.
AI then asked how I'd chosen the target structure.
The direction I supplied was, “I want to avoid changing UI code in lots of places every time the server changes.” I worked out the specific design with AI. A mapper, for example, is code that converts data from the server into the form the UI uses. Putting the conversion code in one place let us discuss where to make edits when the server changed.
But when I looked back at why I'd accepted the proposal, there were parts I couldn't explain with much confidence.
As we talked, I looked back at what I'd understood and what I'd accepted on trust. I could follow the design explanation through the actual code. Whether there would be fewer places to edit when the server actually changed was a separate question. I hadn't provided an example in our discussion where I'd checked that benefit.
AI suggested choosing one server change I was concerned about and checking which files would need to be modified. The idea was to see whether it reduced how much code needed editing, as I'd wanted, in addition to hearing that the design had been reviewed extensively. I could delegate that check to AI too. I could choose a change that mattered to our project and assess whether the result matched the original requirement.
That's something to try in future work. I haven't run a separate experiment for this post.
We then returned to the demo at the start of this post. If I could understand a well-organized project, why had Astra's code felt so daunting?
That let me reconsider the difficulty I'd felt at the start. I'd seen code that was hard to read and immediately started worrying about my role. I hadn't planned to keep reading and maintaining the demo's code. The demo had shown me the result I wanted to see.
A project I planned to keep developing would be different. In the architecture work we'd discussed, I needed to understand the impact of changes. With this demo, I'd achieved the goal without understanding all the code. There was no reason to require the same level of understanding for both tasks.
I realized that searching for something a person could contribute might lead us to add work to a task that was already finished. If we'd reached today's 100%, we could stop there. The question of 150% didn't have to become a demand to keep revising every project forever.
Finally, I asked AI to answer based on everything we'd discussed.
This conversation didn't prove which tasks people must keep doing forever. Nor did I measure the effect of my contributions. But I could describe the judgments I was making more clearly than I could at the start.
I drew on my experience to identify what I wanted to change. I gave AI the reasons and context. Sometimes I understood the structure it proposed. Sometimes I found problems by using the result myself. The experience I'd gained from writing code also helped me do these things.
I want to decide how closely to read the code based on what I'm building and the decisions I need to make. For a project I'll keep changing, I need to know which code to edit to make the changes I want. For an important design, I want to apply a change I'm concerned about and check whether the edits stay within the scope I expected. For a demo meant to show a result once, I may be able to check whether it shows what I wanted to see and stop.
For today's 100%, I want to look closely at the result I want and what's still missing. Once I'm satisfied with that level, I want to explore what would be worth making next. That's what I mean by 150%. And I want to do that without judging my role solely by how much code I write myself.