Over the past few weeks during my internship, I had the opportunity not only to write code but also to learn how AI-assisted software development processes actually work. Working with large language models, understanding the logic behind prompt engineering, and transforming an idea into a functioning project was an incredibly educational experience for me. In this article, I will talk about both the AI-based RPG project we developed and the technical concepts I learned throughout the process.

What is Prompt Engineering?

Prompt engineering is the process of designing commands or instructions given to an AI model in a way that produces the most accurate results. At first, it may seem like simply "asking questions," but in reality, it has a significant impact on how the model behaves.

For example, there is a huge difference between telling the same model:

"Write a story."

and saying:

"Create an interactive RPG story set in the Middle Ages with a dark atmosphere and three selectable actions."

In the second example, the model's:

• tone,
• environment,
• output format,
• and user experience

become much more controlled.

Prompt engineering was especially important in our RPG project because the AI needed to:

• generate consistent characters,
• maintain story continuity,
• produce outputs in JSON format,
• preserve the same atmosphere throughout the game.

What Did We Pay Attention to While Writing Prompts?

One of the most important things I learned while writing prompts was that vague commands produce vague results. It is essential to clearly define what the model is expected to do.

Some of the main points we focused on were:

• Clearly defining the output format
• Specifying the role of the model
• Avoiding unnecessary freedom
• Adding rules to maintain consistency
• Considering error scenarios
• Keeping user experience in mind

For example, since we wanted the model to generate JSON instead of plain text, we explicitly defined the required fields inside the prompt:

{
  "karakterAdi": "Kaptan Armand Devereux",
  "karakterArkaplan": "1692 yılında Karayipler’de ün salmış eski bir Fransız korsanıdır. Genç yaşta donanmadan ayrılmış ve kendi mürettebatını kurarak tehlikeli sularda yaşamaya başlamıştır. Altın ticaret gemilerine yaptığı baskınlarla tanınır ancak son yıllarda kayıp bir hazineyi bulmaya takıntılı hale gelmiştir.",
  "karakterDt": "17. yüzyıl, Karayipler",
  "olaylar": "Fırtınalı bir gecede geminizle terk edilmiş bir adaya yaklaşıyorsunuz. Mürettebatınız huzursuz görünüyor çünkü adanın lanetli olduğuna dair söylentiler duyulmuş durumda. Ancak eski bir harita, kayıp hazineye ulaşmanın yalnızca burada mümkün olduğunu gösteriyor.",
  "muhtemelAksiyonlar": [
    "Mürettebatı toplayıp gece hemen adaya çık.",
    "Sabaha kadar gemide bekleyip adayı uzaktan gözlemle.",
    "Haritadaki işaretleri tekrar inceleyerek farklı bir rota belirle."
  ]
}

This structure allowed us to process the data much more efficiently on the application side.

Our Project: Past Life Simulator

During the internship, we developed an AI-powered RPG game called Past Life Simulator.

In the game, the user selects a character such as:

• Pirate
• Knight
• Explorer
• Monsieur

and enters a dynamic story generated entirely by AI.

At each turn, the player is presented with three different actions. Depending on the selected choice, the story changes completely. Unlike traditional branching scenario systems, the content here is generated instantly by artificial intelligence.

In the project, we used:

• Mistral AI API
• Python & Flask
• HTML/CSS
• Vanilla JavaScript

We also paid close attention to mobile compatibility and user experience.

Why Did We Create an SRS Document?

Before starting development, we did not immediately begin coding. First, we prepared an SRS (Software Requirements Specification) document.

At first, I thought this step was unnecessary, but as the project progressed, I understood why it was so important.

The SRS document helped us:

• clarify the project scope,
• define requirements clearly,
• determine which features would be implemented,
• anticipate possible problems,
• provide more accurate guidance to AI tools.

Our SRS document included:

• functional requirements,
• user scenarios,
• API structure,
• interface requirements,
• performance expectations,
• error handling,
• security details.

For example, the document explicitly specified that:

• the game would run in a single Python file,
• no JS framework would be used,
• Mistral API would handle AI interactions,
• game progress would not be stored.

Because of this planning process, we were able to move forward more systematically instead of constantly deciding what to do next.

Converting the SRS Document into AGENTS.md / CLAUDE.md

One of the most interesting experiences was converting the SRS document into a technical planning document that AI tools could understand.

For this process, we used Claude.ai.

A standard SRS document is written for humans, but AI coding tools work better with documents that are:

• shorter,
• more technical,
• more task-oriented.

Because of this, we simplified information such as:

• project goals,
• technical requirements,
• tasks,
• file structures,
• API behaviors

and converted them into AGENTS.md formats.

During this transformation process, we:

• removed unnecessary explanations,
• organized technical tasks into structured lists,
• created clear commands that AI tools could execute.

In a way, prompt engineering logic was involved here as well.

Developing the Application with OpenCode Desktop

Afterward, we started developing the project using OpenCode Desktop.

The most impressive part of OpenCode was its ability to assist development through natural language commands.

For example, commands like:

• "Fix this error"
• "Move to the next step"
• "Improve mobile compatibility"
• "Reorganize the buttons"

could be used to modify the project.

During this process, I realized something important: AI tools do not create miracles on their own. If they are not guided correctly, they can produce incomplete or incorrect results. That is why understanding software development logic is still extremely important.

Human control remains essential, especially in areas such as:

• debugging,
• performance optimization,
• user experience,
• code organization.

What Did I Learn from This Process?

This experience taught me not only about artificial intelligence but also about software development discipline itself.

Some of the most important lessons I learned were:

• Planning comes before coding.
• Writing good prompts is a serious skill.
• AI tools can guide developers, but control should still remain with humans.
• Documentation is much more important than I initially thought.
• User experience is just as valuable as technical success.

Especially the SRS preparation and prompt engineering aspects completely changed my perspective on software development.

During this internship, I improved both my technical skills and my understanding of how important AI-assisted software development processes will become in the future.