How I used Claude and ChatGPT to organize student-record materials and reduce hallucinations.

Using Generative AI to Help Write Student Records

How I Do Vibe Coding

Eric Schmidt on the Future of AI

Building a School Community Website

Building a Career Counseling Chatbot with Claude API

Deleting Two Projects

What I Took from a Conversation Between Elon Musk and Sam Altman

Building a Face-Recognition Attendance System with Python

How Do AI Translators Understand Grammar?

My Programming Journey

Building a Digital School Attendance System

The Power of Open-Source AI

The Singularity Is Coming

Turning What I Don't Know into Questions

Why Do LLMs Get Easy Things Wrong?


# Turning What I Don't Know into Questions

There is a sentence I hear often when talking with friends:

“I don't know how to do that.”

In the past, that sentence felt natural. If you did not know something, it was normal that you could not do it. To learn, you had to buy a book, take a class, or find someone who already knew. Access to information was a barrier by itself.

Things are a little different now.

If I do not know something, I can open ChatGPT and ask. If I do not even know what I do not know, I can ask, “Tell me what I need to learn first.” If a concept is difficult, I can ask for a simpler explanation and then ask for examples. If code throws an error, I can paste the error message and ask why it happened.

AI does not always give correct answers. That is exactly why another ability has become more important: asking, checking, and asking again.

I do not think the gap in the AI era is simply between people who know and people who do not. It is increasingly between people who ask questions when they are uncertain and people who stop because they are uncertain.

I once wrote [My Programming Journey](/blog/my-programming-journey) on this blog, tracing the path from taking apart hardware as a child to becoming interested in web development and AI. Looking back at that path, I want to write about one habit I have repeated:

Instead of stopping when I do not know, I ask, search, and try something small.

## I Did Not Start by Knowing Everything

I did not begin because I already understood what I was doing.

As a child, I was more interested in electronics and hardware than in code. I used a Galaxy S2 that my brother had owned and a Galaxy Note 3 that my mother had used. I installed TWRP, looked for custom ROMs on XDA, and experimented with rooting and overclocking while I was still in elementary school.

I did not understand the Android architecture properly. I was simply curious. I wanted to change the device myself instead of using it only as it was given to me.

I searched, followed instructions, and searched again when something failed.

Around 2018, I wanted to play PUBG so badly that I bought a used i5-4690 and GTX 1050 Ti. I asked a bank employee how to make a transfer, bought the parts on Bungaejangter, and assembled them myself. I did not know everything. I asked, watched YouTube, checked whether the parts matched, and looked again when something failed.

That was probably when the habit began.

I did not start because I knew what to do. I gradually became comfortable with not stopping while I was still learning.

## At First, I Wanted to Make a Game

My first interest in software was not grand either.

I wanted to make an open-world sim-racing game set in Korea. I bought a C++ book and installed Unreal Engine. It did not go well. Game development was much harder than I expected and too large for me at the time.

So I moved to the web.

I followed HTML, CSS, and JavaScript tutorials on YouTube. I watched channels such as Nomad Coders and Coding Noona and built clones. I found a free domain, created a GitHub account, and made a personal portfolio site.

The code was weak and the design was rough. Still, seeing a page I built have its own internet address and receive visitors was a powerful feeling.

Hardware needs parts, money, and physical limits. Software can be copied, deployed, and used by other people once it is built. That possibility attracted me.

## Meeting ChatGPT for the First Time

I first tried ChatGPT around January 2023, before entering my second year of high school.

I asked about a web-development roadmap: what to learn after HTML, how to study JavaScript, and which order to follow to build a website.

By today's standards, ChatGPT 3.5 was unstable and often wrong. It was still a shock.

Before that, I had to search through results one by one. Now I could describe what I did not know in words and have a tool think alongside me.

The important part was not getting an answer immediately. It was being able to move from uncertainty to the next question.

That was when I first felt that AI could expand an individual's ability to make things.

## Turning Nearby Friction into Tools

Around my second year of high school, when Claude 3 Opus came out, I began vibe coding seriously.

It was not systematic like it is now. I asked questions in Claude's web interface, copied the result into VS Code, and pasted the error back when something failed. I did not refactor properly, and I often put several features in one file.

Still, I made things that worked.

I built a school community page, a QR attendance system, small web services, and an AI chatbot. Most did not start with a large market analysis.

I built the QR system because a friend had to record attendance by hand every morning. I built Sungblab AI because friends seemed unable to use tools such as ChatGPT and Claude comfortably, so I wanted to put several models in one place. I built a League of Legends 5v5 scrim team picker because making teams while playing with friends was annoying.

Looking back, most of my projects started with friction I had seen nearby.

I built something when a friend was inconvenienced. I built something when I was annoyed. When people around me did not know how to do something, I tried turning it into a tool.

I was not a perfect developer or a great entrepreneur. I simply asked when I did not know, built when I saw a problem, and fixed things again when they failed.

## What You Can Do After “I Don't Know How”

That is why I sometimes feel a little sad when I hear “I don't know how to do that.” Of course, people can genuinely not know. I do not know most things either.

But today, there is an action available immediately after “I don't know.”

Ask, “Then what should I ask first?”

If you want to build a website and know nothing, ask:

```text
I want to build a website but I know nothing.
Tell me what I should learn first, step by step.
```

If the explanation is difficult, ask again:

```text
That explanation is difficult.
Explain the roles of HTML, CSS, and JavaScript with an analogy.
```

If it still feels overwhelming, make it smaller:

```text
Create the smallest web-page example I can follow today.
```

The same applies outside development. If you have a business idea but do not know where to start, ask what you need to learn to test whether people actually have that problem. If investing feels overwhelming, ask what order a beginner should use to understand an income statement.

AI will not solve everything. But the environment to ask the first question is open to more people now.

## Questions Are Not Just Prompt Engineering

People talk about prompt engineering a lot. I do not think questioning ability is simply the ability to make a prompt look nice.

It is closer to the ability to break a problem into pieces.

It means separating what I know from what I do not know, organizing a situation into a unit an AI can answer, and verifying the result instead of trusting it automatically.

A beginner might ask:

```text
Build a login feature.
```

With more experience, the question changes:

```text
I want to build login with Supabase Auth in Next.js.
I need email login, session persistence, and protected routes.
What structure would work well?
```

Later, the constraints become part of the question:

```text
Next.js server and client components are mixed.
I want to keep the session during SSR and handle protected routes.
What structure avoids a hydration mismatch?
```

The quality of a question eventually comes from the quality of understanding.

That does not make fundamentals less important in the AI era. It makes them more important. Good questions come from knowledge.

## The More I Vibe-Coded, the More I Needed Fundamentals

At first, it can feel as if AI means you need to study development less. Simple CRUD, login, UI, API connections, and deployments can indeed be built quickly with AI.

I built many things that way.

But once a project passes a certain size, a wall appears.

The folder structure becomes tangled. The database design becomes strange. Authentication and authorization become unclear. State management breaks. Types fail. The AI builds the same feature in another way. Eventually I cannot remember why I designed it that way.

That is when the lesson becomes clear:

Even if AI writes the code, design does not disappear.

It becomes more important.

I need to understand SSR and CSR to ask good questions in Next.js. I need database relationships to specify a schema. I need authentication architecture to fix permission problems. I need networks and deployment to solve issues that work locally but fail on the server. I need tests to check whether AI-generated code is actually correct.

Vibe coding does not eliminate development study. It changes the order in which development is learned.

In the past, someone might learn syntax, then data structures, then a framework, and finally build a project. Now it is common to build a project first, get stuck, ask questions, and feel the need for computer science and software engineering through the work itself.

That happened to me. I started by asking Claude for code and pasting errors. As projects grew, I began thinking about repository structure, documentation, tests, verification, and handoff.

AI did not do everything for me. Managing what AI produced made a better structure necessary.

## Not Knowing Is Not the Problem

I do not think the important ability in the AI era is knowing everything from the start.

Almost nobody does. I certainly do not. Using AI often makes me notice how much I do not know.

The important thing is not stopping while you are uncertain.

Ask when you do not know. Verify when the answer seems strange. Break the question down when it is hard. If you do not know what you do not know, ask that first. Once you have an answer, try it on a small scale. Ask again when the experiment gets stuck.

I think people who repeat this loop will learn faster.

Questions alone do not solve everything. You still have to act, see the failure, and fix it.

AI makes starting easier.

Finishing is still a human responsibility.

AI opens the same input box to many people, but they do not all get the same result.

One person stops at “I don't know how to do that.” Another starts with “Then what should I ask?” One trusts the first answer. Another verifies, compares, and tries it. One says “build it” vaguely. Another breaks down the problem, organizes the context, and sets verification criteria.

I think this gap will grow.

Not knowing is not the problem.

Stopping because you do not know is the problem.

The most important ability in the AI era, as I see it, is this:

The ability to turn what you do not know into a question.


Why turning uncertainty into questions and trying small experiments matters in the AI era.


# Why Do LLMs Get Easy Things Wrong?

LLMs can produce natural writing and still fail at a strangely easy question, such as counting the `r`s in `strawberry`. This is less like a simple bug than a consequence of the model's structure.

## Starting with Transformers

Since the 2017 paper “Attention is All You Need,” the transformer has become the basic architecture behind modern LLMs. Models such as ChatGPT, Claude, and LLaMA all follow this line of development. Transformers have expanded beyond text into images, audio, and translation, so it is difficult to understand the current AI boom without understanding them.

## Where LLMs Commonly Wobble

LLMs often struggle to control text length. Ask for 200 words and they may return 150 or 250. They are also weak at exact string patterns: they can miscount the `r`s in “strawberry” or mishandle repeated patterns in Korean.

<Math math="Accuracy_{counting} = \\frac{\\text{Correct Count}}{\\text{Total Attempts}} \\times 100" />

## The Transformer Architecture

The core of a transformer is attention: looking at the relationships among words in a sentence at the same time.

<Math math="Attention(Q, K, V) = softmax(\\frac{QK^T}{\\sqrt{d_k}})V" block />

The amount of computation grows quickly as the sequence gets longer.

<Math math="Complexity = O(n^2 \\cdot d)" block />

Here, `n` is the sequence length and `d` is the dimension.

## Self-Attention and Memory

Transformers use multi-head attention to examine word relationships from several perspectives. It performs well, but it also consumes significant computing resources.

<Math math="MultiHead(Q, K, V) = Concat(head_1, ..., head_h)W^O" block />
<Math math="where\\ head_i = Attention(QW^Q_i, KW^K_i, VW^V_i)" block />

Because each head is calculated separately, memory requirements also grow.

<Math math="Memory_{required} = h \\times (3 \\times d^2) +" block />
<Math math="BatchSize \\times SeqLength \\times ModelDim \\times 4" block />

## Chain-of-Thought Prompting

Chain-of-Thought (CoT) prompting can reduce some of these weaknesses. Instead of asking for an answer immediately, it asks the model to write intermediate steps.

<Math math="P(answer|steps, problem) =" block />
<Math math="\\frac{P(steps|problem) \\times P(answer|steps)}{P(problem)}" block />

### A Practical CoT Example

Ordinary prompting and CoT prompting feel quite different.

Ordinary prompting:

```
Q: How many 'r's are in strawberry?
A: 2
```

CoT prompting:

```
Q: Count the 'r's in strawberry step by step.
A: Step 1: inspect each letter
   s(no r) -> t(no r) -> r(first) -> a(no r) -> w(no r)
   -> b(no r) -> e(no r) -> r(second) -> r(third) -> y(no r)
   Total: 3
```

## Hardware Requirements and Constraints

Modern transformer models need substantial computing power.

<Math math="Computing_{power} =" block />
<Math math="\\frac{Parameters \\times Tokens}{Time}" block />

This is why high-performance hardware such as NVIDIA GPUs matters. Discussions about model performance eventually return to electricity, memory, and GPU prices.

## Why Other Architectures Are Appearing

### MOE (Mixture of Experts)

MOE combines several expert models and activates only the experts needed for an input. Instead of making one model handle every calculation, it selects a subset. The goal is to operate a larger model while reducing computation and memory.

<Math math="Output = \\sum_{i=1}^n g_i(x)f_i(x)" block />

`g_i(x)` is the gating function that selects experts, and `f_i(x)` is the output of each expert model.

## Scaling Up

Hyperscale AI grows both the model and the computing system. A simplified scaling law might look like this:

<Math math="Performance =" block />
<Math math="\\alpha \\log(N) + \\beta \\sqrt{C}" block />

`N` is the number of parameters, `C` is computing power, and `alpha` and `beta` are scaling coefficients.

## The Mamba Architecture

Mamba uses selective state-space modeling. It is an attempt to address the cost of long contexts in a way different from transformers.

<Math math="h_t = \\phi(x_t, h_{t-1})" block />
<Math math="y_t = \\psi(h_t)" block />

Mamba has linear time complexity, so it can process long sequences more efficiently. Its lower memory use is one reason it is discussed for long-context tasks.

## Future Directions

AI needs to become not only smarter but also more efficient. Resource use relative to performance can be simplified as:

<Math math="Efficiency = \\frac{Performance}{Resource_{usage}}" block />

This keeps distributed processing, modular architectures, and resource optimization important. Hybrid architectures, biologically inspired models, and quantum-computing integration are also being studied in this direction.

## A Midway Summary

Transformers are an important foundation for AI, but their limits are clear. That is why approaches such as MoE, Mamba, SSM, and Jamba keep appearing. The central goal is to process longer contexts at lower cost.

## What to Watch Next

AI research will continue to examine compute efficiency, memory use, long-context processing, and hybrid structures. Simply making models larger makes the cost problem too large.

## New Architectures

### SSM (State Space Model)

SSMs are often discussed as an alternative to transformers. They process input while continuously updating a system state.

<Math math="h_{t+1} = Ah_t + Bx_t" block />
<Math math="y_t = Ch_t + Dx_t" block />

Their linear time complexity makes long sequences more efficient, with lower memory use than transformers.

### Mamba

Mamba builds on SSMs with selective state updates.

<Math math="S_{t+1} =" block />
<Math math="\\Delta_t \\odot (A_t S_t + B_t x_t)" block />

The selective update improves compute efficiency and considers hardware optimization as well. It is especially promising for long contexts.

### Jamba and Hybrid Structures

Jamba combines transformer and Mamba strengths. In simplified form:

<Math math="Output = \\alpha T(x) + (1-\\alpha)M(x)" block />

The model has 120B active parameters and aims to combine throughput with long-sequence processing. It uses transformer parallelism together with Mamba's sequence efficiency.

## Open Questions

### Real-Time Optimization

Microsoft's decoder-based transformers are discussed in the context of real-time optimization. Latency can be simplified as:

<Math math="Latency = \\frac{TokenCount}{ProcessingSpeed}" block />

Better optimization would let LLMs fit more naturally into real-time applications.

### Multimodality

AI systems are moving beyond text toward images, audio, and interaction.

<Math math="Understanding =" block />
<Math math="f(Text, Vision, Audio, Interaction)" block />

This is a move toward handling several kinds of sensory information together.

### Compute Efficiency

The architectures also differ in computational complexity:

- Transformers are limited on long sequences by `O(n²)` complexity.
- SSMs and Mamba provide more efficient linear `O(n)` processing.
- Jamba aims to balance efficiency and performance with `O(n·log(n))` complexity.

# Closing

When I use an LLM, I often think, “How can it be this smart and still get that wrong?” Looking at the architecture makes the reason clearer: these models do not count and calculate exactly as people do.

Future models therefore need more than scale. They need to handle longer contexts, run with fewer resources, and connect to tools or external systems when necessary.

As I keep using and building with AI, I want to understand its limits as well as its strengths. That helps me avoid both overestimating AI and dismissing it as useless.

## References

1. Vaswani, A., et al. (2017). “Attention Is All You Need.” [arXiv:1706.03762](https://arxiv.org/abs/1706.03762)
2. 안될공학. (2023). “Beyond Transformers: MoE, SSM, and the Future of AI.” [YouTube](https://youtu.be/NSt259rpsKM?si=mugw0frQqWOJIUcT)
3. Gu, A., et al. (2023). “Mamba: Linear-Time Sequence Modeling with Selective State Spaces.” [arXiv:2312.00752](https://arxiv.org/abs/2312.00752)
4. Wei, J., et al. (2022). “Chain of Thought Prompting Elicits Reasoning in Large Language Models.” [arXiv:2201.11903](https://arxiv.org/abs/2201.11903)
5. Brown, T., et al. (2020). “Language Models are Few-Shot Learners.” [arXiv:2005.14165](https://arxiv.org/abs/2005.14165)


Why LLMs can write well yet struggle with counting and other simple tasks, viewed through the transformer architecture.

Using Generative AI to Help Write Student Records

Why Do LLMs Get Easy Things Wrong?

Turning What I Don't Know into Questions

Knowledge graph

Related Posts

What I Took from a Conversation Between Elon Musk and Sam Altman

Lessons from Reed Hastings and Sam Altman

The Singularity Is Coming