AI Can Write Code, But What About Us?

🇮🇩 Originally written in Indonesian.
This English version was AI-assisted and adapted for a more natural reading experience. It is not a literal translation.
Open Link

Introduction

Just yesterday.

(Well, as of when this article was drafted.)

There was an event called Jatim Developer Day.

Actually, it's an annual event. However, 2026 might be the first time I've heard about it and had the opportunity to attend.

Overall, it was pretty good.

Although there were some shortcomings from the organizers, I'd still like to express my gratitude, especially to the volunteers and communities who helped keep the event running.

Well...

There were three keynote speakers whose talks I found quite interesting.

• Sandika Galih — Tech Talent 2.0: How to Learn, Adapt, and Stay Relevant Amid the AI Wave

• Nosa Shandy — Security Matters: AI Is the New Attack Surface

• Eko Kurniawan — AI Can Write Code. Can You Design the System? (TBC)

Interestingly, all three keynotes touched on AI.

From how beginners like us should learn and adapt, how we as users should start paying attention to security, to how developers should approach system design.

Come to think of it...

These topics are quite relevant to the current development of AI.

Especially for those of us in the IT world.

So, what exactly is being affected by AI?

Discussion

Looking at the three keynotes, each of them actually had quite a different perspective.

From how we learn and adapt, how AI introduces new challenges in security, to how a developer should approach designing a system.

However, I'd like to take a few things from those talks that I personally found interesting.

As an Informatics Engineering student who is still learning, there are certainly a lot of things I can take away from them.

And this time, I'd like to discuss them in a few points.

(￣︶￣*))

1. We Should No Longer Just Learn, We Need to Master It

With AI...

A lot of tasks can now be done much more easily.

Some tasks that used to take quite a long time can now be completed with just a few instructions.

And yes, AI can do that.

But...

You know about AI SLOP, right?

AI can certainly generate something based on what we ask for.

But what if we don't actually understand what we're asking for in the first place?

For example, when we want to build an application.

We ask AI to create an API, define a database structure, or even design the entire system.

But do we understand the concepts being used?

Do we know why a particular approach should be used?

Do we know whether the proposed solution actually fits the requirements?

Well...

I think this is where mastering the material becomes important.

It's not enough to simply know how to use a technology. We also need to understand how it works, what it's meant for, and when it should be used.

Because AI works based on the context and instructions we provide.

If we don't even understand what we actually need, how can AI produce something that truly matches what we want?

It might even give us a solution that looks correct but doesn't actually solve the problem we're facing.

So, it's not that we have to master everything before using AI.

However, at the very least, we need to have a sufficient understanding of whatever we're working on.

Because how can we guide something if we don't even know where we're going?

2. We Shouldn't Just Use it, We Should Take Control

AI is incredibly powerful.

And we all know that.

As beginners who are still learning, we probably use it quite often.

Whether it's to find references, understand code, fix errors, or even build an application.

But what are you actually using AI for?

And why?

At the event, there was a part of Pak Sandika Galih's presentation that caught my attention.

"Take ConTRoL of your future."

With an emphasis on the word CTRL.

• Core first // build your foundation

• Think user-first // what problem are you trying to solve?

• Review like a senior // decisions matter more than just writing code

• Learn the loop // learn, share, repeat

Come to think of it...

The concept is quite simple, but it's relevant for those of us who are still learning.

When building an application, there's certainly a sense of satisfaction when we finally see it working.

But...

Does the application actually solve a problem?

Does it make things easier for users, or does it just create another burden?

Well, with the CTRL concept, we're not just focusing on how to build an application.

We also need to understand its foundations, identify the problems, and review the results.

So, when using AI, we're not simply asking it to write code.

We already have an idea of what we want to build and how the application should work.

The output from AI also needs to be reviewed.

Does it meet the requirements?

Is the flow correct?

Does the proposed solution actually make sense?

Rather than simply looking at how many features we've managed to build.

There's another part that I find quite interesting.

Learn the loop.

Learn, share, and repeat.

I once heard a saying back when I was in boarding school.

"One of the most effective ways to learn is to teach."

Something along those lines.

When we try to teach something we've learned to someone else, we're indirectly reviewing that material all over again.

In fact, we're also testing our own understanding.

Because understanding something and being able to explain it to someone else are two different things.

If we only follow tutorials or instructions from AI, it doesn't necessarily mean we truly understand the process.

But when we try to explain how something works in our own words...

Well, that's when we can see how much we actually understand.

3. We Can't Reject It, We Have to Adapt

As AI continues to become more advanced...

A lot of jobs are starting to be replaced or made easier.

Yeah.

A lot.

But what kind of jobs?

In my opinion, one of them is work that focuses solely on implementing decisions that have already been made.

When the requirements and solutions are already clear, AI can translate them into code quite quickly.

So, if we're still proud of skills that AI can already perform, what makes us different as developers?

Well...

Looking back at the previous two points, there are actually two things we need to develop: mastery of the subject and the ability to control AI.

Both are closely related.

We need to understand what we're working on so that we can determine what's actually needed. Then, with that understanding, we can guide AI and evaluate the results it provides.

Because if our abilities are limited to knowing how to implement something, AI can do that too.

Maybe even faster and better.

At this point, I was reminded of Pak Eko Kurniawan's presentation.

There was one statement that caught my attention:

"Code is getting cheaper, decisions are getting more expensive."

Come to think of it, that's actually true.

AI can help us write code, create program structures, and even provide several alternative solutions.

But there are many considerations behind a decision that cannot simply be evaluated from a single context.

For example...

When we're building an application, does it need to support offline usage?

If the target users are located in areas with poor internet access, an offline feature might be an important requirement.

However, if the application is used in an environment with a stable internet connection and all data needs to stay synchronized, an online approach might make more sense.

AI can provide recommendations based on the information we give it.

It can even compare the advantages and disadvantages of each approach.

But have we provided all the necessary context?

Do we know all the requirements?

And does the recommendation actually fit the conditions we're dealing with?

This is where I believe a developer's role is still necessary.

It's not just about how to implement something, but also understanding why something needs to be built in a particular way.

So, it's not that AI is completely incapable of making decisions.

AI can help analyze things and provide recommendations.

However, we still need to understand the context, evaluate each alternative, and take responsibility for the decisions we eventually make.

Because in the end, if it's just about knowing how to build something, AI can do that too.

What we need to develop is the ability to understand, determine, and take control of what we build.

Closing

Well...

From those three keynotes, I came away with one impression: the development of AI doesn't mean we should stop learning.

Quite the opposite.

We need to understand what we're working on even better.

Not just how to use AI, but also how to guide it, evaluate its output, and make decisions behind the things we build.

Perhaps in the future, the ability to write code will no longer be the only thing that distinguishes a developer.

Because if it's just about knowing how to build something, AI can do that too.

The real challenge is how we understand problems, determine solutions, and make sure that what we build actually meets the requirements.

And perhaps, that's one of the things we need to start preparing ourselves for as developers.

A little note...

Throughout this article, I've mostly focused on just two keynotes: the presentations by Sandika Galih and Eko Kurniawan.

That doesn't mean the other keynotes weren't interesting or important.

However, from my perspective as someone who is still learning, those two presentations gave me a lot of insight into what I need to prepare myself for as I grow as a developer.

Of course, there are still many other things worth discussing from Jatim Developer Day.

There might even be other perspectives or lessons that I haven't picked up on yet. So, this article is just a small part of what I took away from attending the event.

Thank you to everyone involved in organizing the event, the volunteers, the communities, and of course, the speakers who shared their experiences and knowledge.

And thank you as well to you for reading until the end.

See you in the next post!

Don't forget your cup of coffee today! ☕