
# Deleting Two Projects

Today I deleted UnivMind and OpenCairn. Servers down, repositories gone from GitHub. I could have left them up, but I did not want projects sitting in public when their behaviour was shaky or when I could not explain them even to myself. Anyone landing on my GitHub would read them as the bar for what I build, and I did not want that to be the bar.

## UnivMind

UnivMind was an AI learning service for university students. I assumed course materials would be scattered across PDFs, slide decks, announcements and documents, and they were. During exam season, finding the material, organising it and understanding it again becomes work in its own right. I wanted students to upload all of it, have AI organise it, ask questions, and study in one place.

![The UnivMind landing screen, reading "One class needs just one space."](/images/bio/univmind-landing.jpg)

![The UnivMind dashboard, listing actual class projects and their note counts.](/images/bio/univmind-dashboard.jpg)


UnivMind worked. It was not a broken project — the MVP ran and real users tried it. But over time it started to feel thin.

The problem was not that it lacked features. The problem was whether there was a reason to keep pushing it.

The market already had similar products: NotebookLM, ChatGPT, Claude, Gemini, and a growing number of AI study tools for university students.

Students already had alternatives. They were also more careful than I expected about paying for another service like this.

At first, I thought I could win by simply making it better. Then different questions started to bother me.

Could I really win in this market? Why would a student choose my service specifically? Did the product have a moat? Was I holding on only because I knew how to build it?

In the end I decided UnivMind worked but was not sharp enough, so I deleted it.

## OpenCairn

OpenCairn grew out of a pivot from UnivMind. It began as an AI learning service for university students, but the phrase “AI note-taking app” soon felt too small. I did not want to build just another tool that answered questions about PDFs.

I wanted a system that could hold documents, sources, knowledge graphs, AI workflows, evidence, and an agent ledger in one place. I wanted a knowledge workspace that preserved the reasoning and evidence behind work done with AI, instead of producing only one-off chats.

That was why I chose the name OpenCairn. I was imagining something like an open-source AI Knowledge OS.

The vision was big and the implementation did not keep up. The agent I considered central never worked reliably enough.

![The OpenCairn landing screen, reading "OpenCairn understands what you have read."](/images/bio/opencairn-hero.png)

![OpenCairn in use: a wiki folder tree on the left and an AI agent organising notes on the right. The screen looked like this; the agent behind it never ran as reliably as I wanted.](/images/bio/opencairn-app.png)
 I built it, but I could not turn it into the stable workflow I had imagined.

The problem definition grew too large, the implementation grew too complicated, and the gap between what I wanted to explain and what actually worked kept widening.

OpenCairn failed differently. UnivMind worked but felt thin; OpenCairn had a large vision it could not execute. One was something I could build without a strong reason for anyone to use it, the other pointed somewhere big that the implementation never reached.

## Building Has Become Easier

AI development tools have dramatically lowered the barrier to building an MVP. Services that would once have been difficult to build alone can now be put together surprisingly quickly with tools such as Claude and Cursor. Since high school, I have built and operated an electronic attendance system, school services, and AI chatbots in much the same way. I have also recruited real users and watched them use what I made.

At first that felt like a superpower — I can build this alone, and an idea can become a service. UnivMind and OpenCairn shifted that a little. Building got easier. Creating a reason for anyone to use the thing did not get easier at all.

The ability to build an MVP is different from the ability to build a good product. The ability to build a good product is different from the ability to build a good business.

Being able to write code with AI does not make a customer problem stronger. A working service does not automatically make people pay. A big vision does not automatically make a good product.

AI also lets more people build similar products faster, which is why I think choosing the problem now matters more than shipping another feature.

What problem am I solving? Is it strong enough? Who pays? Why now? Why me? What is the moat? How deeply does the product get into a customer's workflow or tacit knowledge? Those are the questions I look at first now.

## Deleted, But Not Gone

I deleted UnivMind and OpenCairn, but I do not think they are entirely gone. UnivMind showed me the limits of building an AI learning service for university students. OpenCairn taught me that a large vision does not become a product by itself.

Neither project was finished, but both were experiments that changed how I judge what to build. I used to look first at whether I could build it and which features to bolt on. Now I try to start from why it should exist, how strong the problem is, and whether it can get into the user's context at all. Building got easier with AI, which to me means the problem needs choosing more carefully, not less.

Deleting these projects was not simply giving up on them. It was deciding what I would no longer hold on to.

I do not have a full answer for what comes next. One thing is clear though: next time I want to build something smaller, starting from a more concrete problem — something that actually cuts someone's money, time or repetitive work, rather than a vision that only looks impressive or an AI product that is merely interesting to look at.

I deleted UnivMind and OpenCairn, but I want to keep what I learned from them.


Deleting UnivMind and OpenCairn taught me that being able to build something is different from having a reason to keep building it.

Deleting Two Projects


# 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.

![A 2018 post asking about Galaxy S7 Edge CSC firmware on a Korean Android modding forum.](/images/bio/devilloid-csc-post.png)

![Replies to that post working out how to keep the Samsung logo as the boot animation.](/images/bio/devilloid-csc-comments.png)


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.

![The Scrim Manager team builder's blue side roster, with Doran, Oner, Faker, Peyz, and Keria filled in as an example.](/images/bio/scrim-manager-blue-side.jpg)


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

Almost nobody knows everything from the start. I certainly do not, and using AI makes me notice how much I do not know more often, not less. What matters is not stopping while you are uncertain.

Ask when you do not know. Verify when the answer looks strange. Break it down further when you cannot follow it. If you do not know what you do not know, ask that first. Once you have an answer, run it small, and ask again when it gets stuck.

I think people who repeat that loop learn faster. Questions alone do not settle anything, of course — after the question comes doing it, then seeing it fail, then fixing it.

AI makes starting easy; getting to the end is still on the person. In front of the same input box, one person stops at not knowing how and another starts by working out what to ask. I think that gap widens from here.

The problem is not not knowing. It is stopping there. The ability I think matters most right now is turning what you do not know into a question.


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

Turning What I Don't Know into Questions


# How I Do Vibe Coding

People use the phrase “vibe coding” a lot these days. It sounds like telling an AI what you want and letting it write the code. That is how I started too: “build this feature,” “fix this bug,” or “make this UI prettier.” The approach reaches its limit quickly once a project grows.

AI writes code quickly, but when it loses context it writes strange code even faster. It may ignore the existing structure and invent a new abstraction, mark a document as complete without actually verifying anything, or make a broken test look finished from the outside.

My current approach is different. I build the development environment where the AI will work before I try to improve the prompt.

```text
document structure
-> work routing
-> skills harness
-> small implementation slices
-> verification loop
-> review and push
```

I think this entire flow is the real substance of vibe coding.

# 1. Make the Repository Explain Itself

Pasting a long explanation into every AI session does not scale. For a large repository, I decide which documents an agent should read first.

```text
docs/README.md
docs/contributing/roadmap.md
docs/contributing/feature-registry.md
docs/architecture/
docs/agents/
docs/testing/
```

These files are closer to routers than to a simple project introduction. They first separate the feature being changed—web, API, worker, or database—and then explain which rules apply.

For example, a large web-service repository might set boundaries like this:

```text
apps/web        - Next.js UI
apps/api        - API server
apps/worker     - background worker
packages/db     - database schema
packages/llm    - LLM provider abstraction
packages/shared - shared contracts
```

Once those boundaries are fixed in documentation, the AI is less likely to invent a “reasonable-looking” new structure. I do not have to repeat rules such as “do not import the database directly from the frontend,” “put user-facing copy in i18n files,” or “run long worker jobs through Temporal.”

To vibe-code well, the repository's basic context needs to be good before the prompt does.

# 2. Separate Public and Private Operating Documents

I divide documentation into two layers. Documents in the public repository contain stable information that the product and contributors can read. The current development state, failed attempts, next-session prompts, audit notes, and review responses belong in private operating documents instead.

```text
.private-docs/
docs/superpowers/
```

Public documentation should be clean. But an AI agent needs messy working context to do a good job: which branch is in progress, which tests actually passed, and which plan was abandoned. Putting all of that in the README ruins the public documentation. Keeping none of it means repeating the same mistakes in the next session.

So I separate product documentation from operating documentation and tell the AI about the difference. It needs to know what belongs in public docs and what should remain maintainer context.

# 3. Fix the Workflow with a Skills Harness

A skill is a small operating manual that tells an AI what to do in a particular situation. Instead of writing a long instruction every time, I keep rules for each type of work in files.

```text
project-rules
post-feature
parallel-sessions
next-plan
commit-rules
```

`project-rules` defines the codebase rules. `post-feature` makes the agent check documentation, tests, diffs, and status before claiming a feature is finished. `parallel-sessions` explains how to divide worktrees and file ownership when several agents run at once.

I also use skills from the Superpowers plugin:

```text
writing-plans
test-driven-development
systematic-debugging
verification-before-completion
requesting-code-review
receiving-code-review
using-git-worktrees
```

The important instruction is not “AI, please do a good job.” It is “follow this procedure in this situation.” Quality in AI coding does not come from model capability alone. The same model can produce completely different results depending on the routine around it.

# 4. Cut Work into Small Slices

Do not ask an AI to “finish this project.” Cut the work like this instead:

```text
Goal: let an agent propose note updates

1. Add an agent_actions ledger to the database
2. Add preview/apply endpoints to the API
3. Add a review UI to the web app
4. Generate action payloads in the worker
5. Run tests and a smoke check
```

Assign owned files to each slice.

```text
packages/db/src/schema/agent-actions.ts
apps/api/src/routes/agent-actions.ts
apps/web/src/features/agent-actions/
apps/worker/src/worker/agents/
```

This is what makes parallel work possible. One session can own the database and API, another the web UI, and a third the worker agent. The speed of vibe coding comes less from how quickly AI types code than from the ability to divide work without collisions.

# 5. The Verification Loop Matters More Than Implementation

The most dangerous sentence in AI coding is “It is complete.” I therefore put a verification loop before completion.

```text
inspect changed files
-> type check or tests
-> build
-> browser smoke check when needed
-> review git diff
-> update document status
-> commit / push
```

Every task does not need the full test suite. The verification should be the narrowest one that matches the changed scope. If I changed copy, I check i18n parity and the web build. If I changed API permissions, I check route and security tests. If I changed worker ingestion, I check activity-level tests and the payload contract.

The point is not to believe the words “verified” without seeing the result.

```text
Before claiming success, run the actual command.
If it fails, record the failed command and the cause.
Separate what passed from what you have not verified yet.
```

Without this loop, vibe coding is simply a fast technical-debt generator.

# 6. Prompts Get Shorter while the Environment Gets Longer

My prompts have actually become shorter. I used to explain everything at length:

```text
This project has this structure, these rules, and this feature should work like...
```

Now I can say:

```text
Read the current implementation and continue with the next slice.
```

Or:

```text
Review this PR, apply only what is needed, and push it.
```

That is not because the prompt became better. It is because the repository now contains the documents, skills, plans, and verification rules the AI needs to read.

Vibe coding is closer to an operating system than a momentary chat technique. The user gives a short goal. The agent reads the repository context, follows the skills, runs the work, and leaves the verification result behind.

# 7. What I Think Comes Next

If this flow becomes more general, it could look like a `solo-devflow-os`. The idea is to bundle the document structure, skills harness, worktree operation, verification loop, and PR routine into one template so a solo developer does not repeat the same setup every time.

```text
AGENTS.md
docs/README.md
docs/contributing/roadmap.md
docs/contributing/feature-registry.md
docs/testing/
docs/superpowers/plans/
.private-docs/
skills/
scripts/verify/
```

This is not tied to one model or one IDE. Whether you use Codex, Claude Code, or Cursor, the core idea is the same. To help AI work well, a good workshop matters before a good prompt.

# Summary

```text
1. Make the repository explain itself
2. Separate public and private operating documents
3. Keep a skills harness for each kind of work
4. Cut features into small slices
5. Enforce a verification loop before completion
6. Leave the result in documentation and git history
```

This does not make the AI understand everything automatically. It does let one developer operate as if several junior developers were working alongside them. Each session can be imperfect. What matters is that every session reads, builds, verifies, and hands off work in the same way.

I think this is where the difference in development productivity will appear. The question is not who writes the longest prompt. It is who designs the system where AI can work most effectively.


Document structure, a skills harness and verification loops mattered far more than the prompt.

How I Do Vibe Coding

# Building a Career Counseling Chatbot with Claude API

This project records how I built a career counseling chatbot with Claude API. I did not stop at making one API call. I also thought about how to collect student information, structure prompts, and store counseling records.

## 1. Setting Up the Development Environment

### Installing Python

- Install Python 3.8 or later.
- Check **Add Python to PATH** during installation.
- Confirm the installation with `python --version` in a terminal.

### Creating a virtual environment

```bash
# Create a virtual environment
python -m venv venv

# Activate on Windows
venv\Scripts\activate

# Activate on macOS/Linux
source venv/bin/activate
```

### Installing libraries

```bash
conda install flask
conda install -c conda-forge anthropic
conda install python-dotenv
conda install -c conda-forge flask-sqlalchemy
```

I managed the dependencies in `requirements.txt`:

```
Flask==2.0.1
anthropic==0.3.0
python-dotenv==0.19.0
Flask-SQLAlchemy==2.5.1
```

## 2. Configuring Claude API

![API configuration](/images/api설정.png)

### Creating an API key

1. Open the [Anthropic website](https://anthropic.com).
2. Sign up and log in.
3. Open the API section in Console or Dashboard.
4. Click **Create New API Key**.
5. Store the generated key somewhere safe.

I created a `.env` file in the project root:

```
ANTHROPIC_API_KEY=your_api_key_here
FLASK_ENV=development
FLASK_APP=run.py
```

## 3. Setting Up the Project Structure

### Directory structure

```text
project/
├── app/
│   ├── __init__.py         # Flask application initialization
│   ├── templates/          # HTML templates
│   │   ├── index.html      # Main page
│   │   ├── chat.html       # Chat interface
│   │   └── base.html       # Base template
│   ├── static/             # Static files
│   │   ├── css/            # Stylesheets
│   │   └── js/             # JavaScript
│   └── utils.py            # Utility functions
├── config.py               # Configuration
├── requirements.txt        # Dependencies
└── run.py                  # Application entry point
```

### Main configuration files

#### `config.py`

```python
import os
from dotenv import load_dotenv

load_dotenv()

class Config:
    SECRET_KEY = os.urandom(24)
    ANTHROPIC_API_KEY = os.getenv('ANTHROPIC_API_KEY')
```

#### `app/__init__.py`

```python
from flask import Flask
from config import Config

def create_app():
    app = Flask(__name__)
    app.config.from_object(Config)

    from app.routes import main
    app.register_blueprint(main)

    return app
```

## 4. Building the Web Interface

### Main page

![The first page](/images/첫번째.png)

I built the main page quickly with Bootstrap. It was easy to make it responsive, and I included a welcome message and service introduction, a button to start chatting, a usage guide, and recent counseling history for logged-in users.

### Chat interface

![The second page](/images/9번째.png)

The chat screen included several features so it felt like an actual counseling session:

1. Live message display
2. Different styles for user and AI responses
3. An input field and send button
4. Automatic scrolling through the conversation
5. A loading indicator

```html

<div class="chat-container">
  <div class="chat-messages" id="messageArea">
    
  </div>
  <div class="input-area">
    <input type="text" id="userInput" placeholder="Enter your question..." />
    <button onclick="sendMessage()">Send</button>
  </div>
</div>
```

## 5. Connecting Claude API

### API call

```python
# app/utils.py
import anthropic

def get_claude_response(message):
    client = anthropic.Client(api_key=os.getenv('ANTHROPIC_API_KEY'))

    try:
        response = client.messages.create(
            model="claude-3-opus-20240229",
            max_tokens=1000,
            messages=[{
                "role": "user",
                "content": message
            }]
        )
        return response.content[0].text
    except Exception as e:
        return f"Error: {str(e)}"
```

### Prompt design

I designed a separate prompt for career counseling. Sending only “give me counseling” produced an answer that was too broad, so I passed student information and counseling criteria together.

```python
def engineer_prompt(user_info, user_message):
    system_prompt = """You are an experienced career-counseling AI for high-school students.

Consider these areas during counseling:

1. Academic ability
- Analyze achievement and preferences by subject
- Analyze learning style and study attitude
- Consider activities outside class and self-directed learning
- Consider experience with advanced study in a specific field

2. Aptitude and interests
- Use MBTI and job-fit as one input, not a diagnosis
- Connect hobbies and interests to possible careers
- Consider club and school activities
- Consider volunteer work and civic participation

3. Career exploration and planning
- Provide information about desired job families
- Explain required skills and qualifications
- Introduce related majors and curricula
- Suggest admissions and preparation strategies

4. Skills-development plan
- Suggest study strategies
- Plan relevant certificates and preparation
- Improve foreign-language and computer skills
- Suggest reading and general-education activities

5. Psychological support
- Suggest ways to manage academic stress
- Give advice for career anxiety
- Strengthen confidence and motivation
- Support a positive self-image

6. Future outlook
- Explain industry trends in the field of interest
- Discuss promising future occupations
- Explain how technology may change work
- Connect social change with career adaptability

7. Practical action plan
- Short-term goals (6 months to 1 year)
- Mid-term goals (1 to 3 years)
- Long-term goals (3 to 5 years)
- Concrete actions and a timeline"""

    user_context = f"""
# Basic student information
- Name: {user_info['name']}
- Age: {user_info['age']}
- Grade: {user_info['grade']}
- Academic track: {user_info['academic_track']}

# Academic status
- Performance: {user_info['academic_performance']}
- Favorite subject: {user_info['favorite_subject']}
- Disliked subject: {user_info['disliked_subject']}
- Learning style: {user_info.get('learning_style', 'No information')}

# Career exploration
- Interests: {user_info['interests']}
- Career interests: {user_info['career_interests']}
- Desired future job: {user_info['future_job']}
- Role model: {user_info['role_model']}"""

    return system_prompt + "\n\n" + user_context + "\n\nStudent message: " + user_message
```

#### Response structure

```html
<h2>Overall analysis</h2>
[Professional analysis of the student's traits and situation]

<h2>Career-fit assessment</h2>
[How the desired path matches current abilities]

<h2>Personal development plan</h2>
[Step-by-step goals and actions]

<h2>Recommended materials</h2>
[Personalized learning materials and activities]
```

Fixing those four headings in advance mattered. Without them the length and the order of the answer changed every time, which made it awkward to drop into the page.

#### What I changed while refining the prompt

The biggest win was breaking the student's information into fields instead of writing it as prose. A line like "a second-year science-track student who likes maths" leaked less reliably than `grade: 2` and `track: science` on separate lines.

I tried feeding in MBTI and never decided whether it helped. It shifted the tone of the answer, but not the substance, so I left it as optional.

What clearly hurt was putting instructions like "be specific" in the prompt. That produced longer generalities. Fixing the output sections instead got me specificity for free.

## 6. Connecting the Database

### SQLAlchemy model

```python
from app import db

class ChatHistory(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    user_message = db.Column(db.Text, nullable=False)
    ai_response = db.Column(db.Text, nullable=False)
    timestamp = db.Column(db.DateTime, default=datetime.utcnow)
```

### Saving and loading conversations

```python
def save_chat(user_message, ai_response):
    chat = ChatHistory(
        user_message=user_message,
        ai_response=ai_response
    )
    db.session.add(chat)
    db.session.commit()
```

## 7. Security and Error Handling

### API-key security

- Use environment variables.
- Add `.env` to `.gitignore`.
- Keep production security settings separate.

### Error handling

```python
@app.errorhandler(500)
def internal_error(error):
    return jsonify({
        'error': 'Internal server error',
        'message': str(error)
    }), 500
```

## 8. Preparing for Deployment

### Production settings

```python
# config.py
class ProductionConfig(Config):
    DEBUG = False
    SQLALCHEMY_DATABASE_URI = os.getenv('DATABASE_URL')
```

### Running the server

```bash
gunicorn run:app
```

## Closing Thoughts

Building this project taught me that simply “adding a chatbot” requires more structure than I expected. API-key management, prompt design, conversation storage, and error handling all have to be handled before the result is actually usable.

The areas I practiced were Flask, API integration and asynchronous handling, database design, frontend interfaces, and security and error handling.

If I improved it further, I would add:

- User authentication
- Counseling-history analysis and reports
- Multilingual support
- A voice interface
- A mobile-app version

The full source is available on [GitHub](https://github.com/Sungblab/ai_career_advisor). There are still many things I would clean up, but connecting Claude API to a real service was valuable practice.

<YouTubeEmbed id="6ptUPSYBBtA" title="Career counseling chatbot using Claude API and Flask" />

What I learned about design, prompts, and storage while building a career counseling chatbot with Claude API and Flask.

Building a Career Counseling Chatbot with Claude API


# Building a Face-Recognition Attendance System with Python

## 1. Project Overview

This is a face-recognition attendance system built with Python's `face_recognition` library and PyQt5. I wanted to process attendance automatically with a camera rather than a QR code. While building it, I learned that the surrounding features—UI, exception handling, and bulk registration—mattered even more than face recognition itself.

### Features

- Real-time face recognition and attendance checking
- Registering and managing new faces
- Saving and exporting attendance records
- An intuitive graphical user interface
- Bulk face registration

## 2. Development Environment

```bash
pip install face_recognition
pip install PyQt5
pip install opencv-python
pip install numpy
pip install Pillow
```

The main libraries are:

- `face_recognition`: core face-recognition functions
- `PyQt5`: GUI implementation
- `opencv-python`: camera-stream processing
- `Pillow`: image processing
- `numpy`: array and matrix operations

## 3. System Structure

### 3.1 Overall structure

I divided the program into three main classes:

1. `AttendanceSystem`: main-window class
2. `AttendanceTab`: attendance-checking tab
3. `ManagementTab`: face-management tab

Each class has a relatively focused responsibility.

### 3.2 `AttendanceSystem`

This class owns the main window and the overall UI style.

```python
class AttendanceSystem(QMainWindow):
    def __init__(self):
        super().__init__()
        self.initUI()
        self.showMaximized()  # Start maximized

    def initUI(self):
        self.setWindowTitle('Face Recognition Attendance System')
        self.setStyleSheet("""
            QMainWindow { background-color: #f0f0f0; }
            QPushButton {
                background-color: #2196F3;
                color: white;
                border: none;
                padding: 12px 24px;
                border-radius: 6px;
                font-size: 14px;
                min-width: 120px;
            }
        """)
```

### 3.3 `AttendanceTab`

This is the core class for attendance. It handles the live camera and face-recognition loop.

#### 3.3.1 Initialization and UI

```python
class AttendanceTab(QWidget):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.initUI()
        self.camera = None
        self.timer = QTimer()
        self.timer.timeout.connect(self.update_frame)
        self.is_running = False
        self.frame_count = 0
        self.known_face_encodings = []
        self.known_face_names = []
        self.load_known_faces()
        self.present_students = set()
```

#### 3.3.2 Real-time recognition

Frame processing and recognition run in this method. I process every third frame and resize it to one quarter of the original size to improve speed.

```python
def update_frame(self):
    ret, frame = self.camera.read()
    if ret:
        process_this_frame = self.frame_count % 3 == 0
        self.frame_count += 1

        if process_this_frame:
            height, width = frame.shape[:2]
            small_frame = cv2.resize(frame, (width//4, height//4))
            rgb_small_frame = cv2.cvtColor(small_frame, cv2.COLOR_BGR2RGB)

            try:
                face_locations = face_recognition.face_locations(
                    rgb_small_frame, model="hog"
                )
                if face_locations:
                    face_encodings = face_recognition.face_encodings(
                        rgb_small_frame, face_locations
                    )
                    for (top, right, bottom, left), face_encoding in zip(
                        face_locations, face_encodings
                    ):
                        if self.known_face_encodings:
                            face_distances = face_recognition.face_distance(
                                self.known_face_encodings, face_encoding
                            )
                            best_match_index = np.argmin(face_distances)
                            if face_distances[best_match_index] < 0.6:
                                name = self.known_face_names[best_match_index]
                                self.record_attendance(name)
                                self.show_notification(name)
            except Exception as e:
                print(f"Recognition error: {str(e)}")
```

#### 3.3.3 Recording attendance

The attendance method saves a record and updates the interface. It also prevents duplicate records during the same session.

```python
def record_attendance(self, name):
    try:
        current_time = datetime.datetime.now()
        time_string = current_time.strftime('%H:%M:%S')
        if name in self.present_students:
            return

        faces_dir = "faces"
        image_path = os.path.join(faces_dir, f"{name}.jpg")
        if os.path.exists(image_path):
            pixmap = QPixmap(image_path)
            pixmap = pixmap.scaled(
                250, 250, Qt.KeepAspectRatio, Qt.SmoothTransformation
            )
            self.recent_face_label.setPixmap(pixmap)
            self.status_label.setText(f'✓ Attendance confirmed for {name}.')
            self.update_attendance_table(name, time_string, pixmap)
            self.save_attendance_record(name, time_string)
            self.present_students.add(name)
            self.update_absent_list()
    except Exception as e:
        print(f"Error recording attendance: {str(e)}")
```

### 3.4 `ManagementTab`

This class handles face registration and management. I implemented both single registration and bulk registration.

#### 3.4.1 Registering one face

```python
def register_face(self):
    try:
        file_name, _ = QFileDialog.getOpenFileName(
            self, "Choose a face image", "",
            "Image files (*.jpg *.jpeg *.png)"
        )
        if file_name:
            name, ok = QInputDialog.getText(
                self, 'Enter a name', 'Enter the name to register:'
            )
            if ok and name:
                faces_dir = "faces"
                if not os.path.exists(faces_dir):
                    os.makedirs(faces_dir)
                new_path = os.path.join(faces_dir, f"{name}.jpg")
                counter = 1
                while os.path.exists(new_path):
                    new_path = os.path.join(faces_dir, f"{name}_{counter}.jpg")
                    counter += 1
                image = Image.open(file_name).convert('RGB')
                image.save(new_path, 'JPEG', quality=95)
                self.known_faces.append((name, new_path))
                self.update_face_grid()
                QMessageBox.information(
                    self, 'Registration complete', f'Face registered for {name}.'
                )
    except Exception as e:
        QMessageBox.warning(self, 'Error', f'Registration failed: {str(e)}')
```

#### 3.4.2 Bulk registration

Bulk registration walks through a folder, skips duplicates, checks whether a face can be detected, and reports successful, skipped, and failed files.

```python
def bulk_register_faces(self):
    try:
        folder_path = QFileDialog.getExistingDirectory(
            self, "Choose a folder containing images"
        )
        if folder_path:
            success_count = 0
            skip_count = 0
            fail_count = 0
            error_files = []
            valid_extensions = ('.jpg', '.jpeg', '.png')

            for filename in os.listdir(folder_path):
                if filename.lower().endswith(valid_extensions):
                    try:
                        file_path = os.path.join(folder_path, filename)
                        name = os.path.splitext(filename)[0]
                        existing_path = os.path.join(faces_dir, f"{name}.jpg")
                        if os.path.exists(existing_path):
                            skip_count += 1
                            continue
                        image = face_recognition.load_image_file(file_path)
                        face_locations = face_recognition.face_locations(image)
                        if face_locations:
                            img = Image.open(file_path).convert('RGB')
                            img.save(new_path, 'JPEG', quality=95)
                            success_count += 1
                        else:
                            fail_count += 1
                            error_files.append(f"{filename} (no face detected)")
                    except Exception as e:
                        fail_count += 1
                        error_files.append(f"{filename} (error: {str(e)})")
            result_message = (
                f"Registration complete:\n\n"
                f"Success: {success_count}\n"
                f"Skipped: {skip_count}\n"
                f"Failed: {fail_count}"
            )
            QMessageBox.information(self, 'Bulk registration complete', result_message)
    except Exception as e:
        QMessageBox.warning(self, 'Error', f'Bulk registration failed: {str(e)}')
```

### 3.5 What I Fixed Because It Was Slow

At first I fed every frame straight into `face_recognition` and the camera moved like a slideshow. So I ran recognition on every third frame, and shrank that frame to a quarter of its width and height before passing it in. I also used HOG detection instead of CNN. I was running this on a laptop CPU, so I chose frame rate over accuracy — and paid for it in missed faces at an angle or in low light.

Moving recognition onto its own thread so the UI stopped freezing happened here too. I did not touch memory management at all.

### 3.6 Errors That Actually Happened

Failing to open the camera was the most common one. `cv2.VideoCapture(0)` is not always the built-in camera depending on the laptop, so I try a few indexes from 0 and use whichever opens.

Registering a face under an existing name used to overwrite the old file; I fixed that. A failed recognition is not an error but a normal state, so it just shows "not recognised" on screen and moves on.

## 4. How to Use It

The first time, you register faces in the management tab. After that you press **Start Attendance** in the attendance tab, the camera opens, and any registered face that comes into view gets recorded with a timestamp. Records export to CSV.

## 5. What I Am Not Happy With

I never measured the recognition rate properly. I stopped at "seems to work," so I have no numbers for how often it fails by lighting or angle.

The code also sits almost entirely in one file. Camera, recognition, storage and UI are tangled together, so changing one thing meant reading all of it.

The full source is on [GitHub](https://github.com/Sungblab/SB_face_recognition_system).

What bothered me most was not performance. It was that the system has to keep photographs of faces on hand. My classmates' faces were sitting as files in a folder on my laptop the whole time, and that never stopped feeling wrong. So the next time I solved the same problem, I did it with QR codes.

<YouTubeEmbed id="OEV1jFOZ5-4" title="Building a face-recognition attendance system with Python" />


What I learned while building a face-recognition attendance system with face_recognition and PyQt5.

Building a Face-Recognition Attendance System with Python


# How Do AI Translators Understand Grammar?

When studying English, I often wonder whether a sentence is grammatical or whether an expression sounds natural. Instead of checking a dictionary or grammar book, we can now ask an AI translator. This post looks at how it handles grammar and context.

## 1. How AI Breaks Down a Sentence

### 1.1 Tense

“I have been studying” means more than simply “study”; it carries the meaning of an activity continuing up to now. A translator estimates tense from the words and patterns in the sentence. A simplified model is:

<Math math="P(tense|sentence) = \frac{P(sentence|tense) \times P(tense)}{P(sentence)}" block />

### 1.2 Active and Passive Voice

“The book was written” and “I wrote the book” describe the same situation differently. The system can compare the likelihood of active and passive interpretations.

<Math math="P(voice|sentence) = \max_{v \in \{active,passive\}} P(sentence|v) \times P(v)" block />

### 1.3 Sentence Structure and Articles

The model estimates parts of speech and dependencies, then uses the noun and surrounding context to choose “a,” “an,” or “the.”

<Math math="P(structure|words) = \prod_{i=1}^n P(pos_i|word_i) \times P(dep_i|pos_i)" block />

## 2. Understanding Context

Context can be simplified as relationships between words and the value each word contributes:

<Math math="Context_{score} = \sum_{i=1}^n \sum_{j=1}^n Attention(w_i, w_j) \times Value(w_j)" block />

## 3. How Accurate Is It?

I can't give a real accuracy number here. That would need a proper benchmark and a scoring rubric, and all I did was paste in a handful of sentences. What I can say is that the answers came back noticeably more natural when I gave the surrounding context than when I sent a bare word or a short sentence.

That matches how studying English went for me. Words I memorised on their own faded; the ones I met inside a real conversation stuck.

## 4. Using It to Study English

AI can check whether a sentence is grammatical and suggest more natural wording. It can also adjust its explanation to the learner's level: a beginner might receive a basic explanation, while an advanced learner can compare nuances such as “good,” “fantastic,” and “phenomenal.” Teachers can use it to create examples, review assignments, and plan learning paths.

## 5. What the Experiments Showed

![Detailed results from the English grammar tests](/images/결과1.png)

![Results from the contextual meaning experiment for “배”](/images/결과2.png)

Across the sentences I tried, it barely missed on simple tense, voice, sentence structure and articles, and it stayed steady on compound tenses and the progressive passive too. On homonyms — the ones you can only resolve once you know the context — the difference was obvious when I supplied the surrounding sentence: it separated the “bank” in “I went to the bank to withdraw money” from “the bank of the river.”

## 6. What I Learned

The interesting part was that the translator did not look at one word alone. It used the surrounding context. It got the tense right on “I go to school” and “I went to school,” read “I have been studying English for 3 years” as a duration rather than a one-off event, and recognised that “The group of students is studying” takes a singular verb. That is still just the handful of sentences I happened to type in.

When a sentence such as “The bank was delicious” was semantically strange, it could flag the problem and suggest alternatives. The process resembles a person narrowing down a word's meaning while reading.

## 7. Closing

All of this is only what came out of a few sentences I typed in. Rather than taking the answer at face value, I found it better to ask why it corrected something and then check that against a dictionary or a grammar reference myself. For me an AI translator is less a replacement for a teacher or a learner than a way to get grammar explanations, context comparisons and phrasing suggestions quickly.

## References

The probability expressions above borrow the transformer and attention concepts these papers introduce. The results under them are my own sentences, not numbers reported in any of them.

1. Vaswani, A., et al. (2017). "Attention is all you need." Advances in Neural Information Processing Systems.
2. Devlin, J., et al. (2019). "BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding." NAACL-HLT.
3. Brown, T. B., et al. (2020). "Language Models are Few-Shot Learners." NeurIPS.


How AI translators handle tense, sentence structure, and context, and how they can help with English learning.

How Do AI Translators Understand Grammar?


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

Watching Elon Musk and Sam Altman talk, I wrote down the parts that stuck. Both of them work at an enormous scale when the subject is AI or future industry, and what interested me was that the conversation kept landing back on one question: which problem are you actually going to solve?

## Electric Aircraft and AI

Musk expects almost every form of transportation, apart from rockets, to become electric eventually. Cars have already shown the direction, and aircraft may follow if battery density and efficiency keep improving.

They also discussed AI and genetic engineering. These technologies carry real risks, but refusing to engage with them can be risky too. I often feel the same way while using and building with AI. Understanding a frightening technology and finding better ways to use it seems more practical than avoiding it.

## A Hundred Good Years Over Immortality

Musk said quality of life matters more than living as long as possible. His idea that roughly one hundred good years could be enough sounded realistic to me. Reducing dementia and diseases of aging may be a more meaningful goal than talking about immortality.

## Sustainable Energy

His description of the sun as a “giant fusion reactor in the sky” stayed with me. If solar power and batteries become good enough, many energy problems could be reduced.

Fusion is difficult not simply because it is dangerous, but because maintaining it stably is hard. Energy may seem separate from AI, but it becomes central once we think about large-scale computing.

## Mars and Humanity's Future

The discussion of Mars was characteristically ambitious. Musk sees becoming a multiplanetary civilization as a kind of insurance. It sounds enormous, but a long-term goal may be what lets a company such as SpaceX keep working on difficult problems.

## Tesla and Autonomous Driving

Tesla does not treat a car as hardware alone. It keeps changing vehicles through software updates and designs hardware and software together.

Autonomous driving always seems to take longer than expected, but the direction is clear. Proving safety and working with regulation matter just as much as implementing the technology.

## On "You Cannot Start a Company After Thirty"

The idea that starting a company becomes impossible after thirty is not very useful. Ideas and execution matter more. Young people may find it easier to take risks, but age alone is too simple a way to judge whether someone can start a company.

Tesla also shows the value of admitting quickly when an initial assumption is wrong and changing course. The ability to keep correcting a strategy may matter more than having a perfect plan from the beginning.

## Spending Most of Your Time on Engineering

Musk says he spends most of his time on engineering and design, with very little on press work. That seems important: people running a technology company still need to spend time on the core problems.

The conversation left me with one thought. People who talk about distant futures eventually return to daily execution and technical detail. Whether the subject is AI, electric cars, or space, a big future requires holding on to the small problems in front of us.

## Source

I watched the Startup Grind Global Conference conversation, through the BZCF translation.


The parts about AI, electrification, and entrepreneurship that stayed with me from a conversation between Elon Musk and Sam Altman.

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


# Lessons from Reed Hastings and Sam Altman

Stories about successful founders can feel distant, but the stories of Netflix's Reed Hastings and Y Combinator's Sam Altman keep returning to the same basics: product, team, and execution.

## The Culture Deck Was Not a Rulebook

Netflix is known for its culture. Its culture deck felt less like a rulebook and more like a document explaining what kind of people the company wanted and how they wanted to work. A principle such as “adequate performance gets a generous severance package” sounds severe, but it also shows how seriously Netflix treated the quality of its team.

## They Cut a Third of Staff and Productivity Rose

During the 2001 dot-com crash, Netflix had to cut a third of its employees. It found that productivity actually increased, and began to focus on “talent density.” That stayed with me: a focused group of people who fit well may matter more than simply collecting a large team.

While competing with Blockbuster, Netflix tried social features, advertising, and used-DVD sales. The decisive work was still improving the core service. When I build products, I need to remember that improving what users truly rely on comes before adding more features.

## Google Was the Thirteenth Search Engine

Altman emphasizes a good idea, product, team, and execution. They sound obvious, but getting all four right at once is difficult.

He also argues that a strong interest in a specific problem should come before “starting a company for its own sake.” Good ideas can look small or strange at first. Google was the thirteenth search engine, and Facebook began as a service for college students. A small start can grow when it addresses a genuinely strong problem.

For products, it is often better to make a small group love something than to make a large group mildly interested. Early products should go deep on what one group truly needs instead of trying to satisfy everyone.

## Part of the Job Is Managing Your Own Head

The reality of a startup CEO looks rougher than it does from the outside. Altman describes managing one's own psychological state as a key part of the role. A CEO has to handle product, fundraising, hiring, and marketing while enduring long periods without immediate results.

Hastings also worked as a CEO during the day and a developer at night, sometimes sleeping at the office during his first company. Entrepreneurship is not just polished presentations or fundraising.

## Instead of Broadcasting Hollywood

Netflix's global strategy was interesting because it did not simply distribute Hollywood content everywhere. It tried to connect stories from each region to a global audience. *Narcos* is one example of content crossing borders in both directions.

The three things I took away are simple: a good team matters, the core of the product has to be strong, and entrepreneurship is ultimately the work of executing for a long time.

What I build is still small, but these stories remind me that large companies also began by solving small problems properly. I want to hold on to the problems I genuinely care about instead of adding features just to make the product look bigger.

---

**Sources:**

- [Sam Altman's Stanford startup lecture](https://youtu.be/X6izsvLQmTs)
- BZCF | BizCafe


What Netflix and Y Combinator taught me about entrepreneurship, culture, and products.

Lessons from Reed Hastings and Sam Altman


# The Singularity Is Coming

Since ChatGPT appeared, I have felt the speed of technological change more directly. AI drawing pictures, writing code, and talking like a person once felt like a distant future. Now these are tools I use every day. Ray Kurzweil's idea of “the singularity” therefore feels more real than it used to.

Kurzweil's law of accelerating returns means that technological progress is not linear; it keeps getting faster. Change may look slow at first, but eventually one technology pushes the next one forward more quickly. That is exactly how AI feels to me.

When ChatGPT first appeared, text conversation was the main experience. Soon it expanded to understanding images, talking by voice, writing code, and using tools. I feel that speed myself as AI takes up more of my development work.

Kurzweil predicted that AI would reach human-level intelligence around 2029. I do not know whether that prediction will be exactly right. But AI is already better than people at specific tasks such as Go, image recognition, coding assistance, search, and summarization.

He also expected this progress to connect software with genetic engineering, nanotechnology, and robotics. Those changes are harder to feel today, but if AI accelerates research and design, other fields may speed up with it.

Examples such as CRISPR, Neuralink, and robotics already exist. Many are still far from widespread use, but experiments are clearly happening faster than before.

This change is both an opportunity and a burden. Society changed dramatically during the Industrial Revolution, but the AI era may arrive much faster. If I just stand and watch, I do not think I keep up.

So how do I prepare? I think the habit of continuing to learn matters most. A few years ago, “prompt engineer” was barely a phrase. Now the ability to work well with AI is becoming a meaningful skill.

Technical skill alone is not enough. There is also the question of who is responsible for a decision an AI made, and what should happen when something goes wrong in autonomous driving or medical AI.

I do not think the singularity is something to fear by default, and blind optimism is not enough either. What matters is understanding and trying these systems ourselves, then separating the useful parts from the dangerous ones.

Kurzweil named 2029 when I was three years old. That year I turn twenty-three. Right or wrong, it is a strange feeling that his prediction lands squarely on top of my twenties.

## References

Kurzweil, Ray. (2005). *The Singularity Is Near: When Humans Transcend Biology*. Viking.


Reading Kurzweil on the singularity again, now that AI is a daily tool, and what I think it asks of me.

The Singularity Is Coming


# Building a School Community Website

Wandaejeon was a community website I built for students at Wando High School. I had seen other schools combine their own community and useful tools, and I thought it would be fun to have something similar at our school.

#### Choosing the stack

I did not need an impressive stack. I needed a structure I could build and fix quickly, so I chose tools I already knew.

- **Frontend**: Vanilla HTML
- **Backend**: Express.js & Node.js
- **Database**: MongoDB
- **Authentication/security**: JWT & bcrypt
- **UI/styling**: Tailwind CSS

## Building the service

### 1. Planning

While talking with a friend, I learned that another school operated its own community and several related systems. That was when I thought our school could use something similar too.

![A school community screen that inspired the planning stage](/images/과구리.png)

I used that site as a reference while deciding what kind of community I wanted to build.

I started during summer vacation, around the time Claude 3.5 Sonnet was released, so I used Claude actively. After the first version, I deployed the frontend to Netlify and the backend to Cloudtype. I even put up a poster at school with my name on it. It was not widely used yet, but it was my first school service that I operated all the way through.

### 2. Development

![The main page of the Wandaejeon school community](/images/완대전.png)

The layout is somewhat similar to the site I used as a reference. With Claude's help, I finished the first draft and testing in about a week. It was my first full-stack project. I can see the rough edges now, but I was proud of it at the time. I used the school's blue as the theme and fetched cafeteria information from the NEIS Open API on the backend.

![The administrator page for writing and managing notices](/images/공지사항.png)

Administrators could view, write, and edit notices.

![A page where logged-in users could submit and vote on petitions](/images/청원.png)

Only logged-in users could submit petitions and vote on them.

![Classroom helper tools including a random draw and timer](/images/도우미.png)

The classroom helper collected tools such as a random draw, timer, and random team picker.

![The about page with the service introduction and developer timeline](/images/소개.png)

The about page introduced the service and included my development timeline at the bottom.

![The school community with an anonymous board](/images/커뮤.png)

The community page required the most thought. I wanted an anonymous board, but I also had to consider protecting logged-in users' anonymity and preventing abuse by people who were not logged in. In the end, I used an IP-based anonymous system inspired by DC Inside.

![A writing page that supports real-name or anonymous posts](/images/글쓰기.png)

I added image uploads. Logged-in users posted under their real names, while visitors could post anonymously.

![A post detail page with recommendations and comments](/images/글.png)

I also looked at DC Inside for the post page. Recommendations, comments, and weekly best posts helped the service feel like a real community.

### 3. Looking back

Wandaejeon was a project I made as part of a school club. It did not have many users, but I learned a lot by handling everything from planning to deployment and promotion. Most of all, I learned that building something and getting people to use it are completely different problems.


What I learned while planning, building, and operating a community website for Wando High School.

Building a School Community Website


# Building a Digital School Attendance System

I started this project because the paper attendance process at school was inconvenient. Checking and organizing paper every time felt inefficient, so I wondered whether QR codes could make attendance easier.

### 1. Planning

I considered fingerprints, RFID cards, and QR codes. For real use at school, cost and accessibility mattered, so I chose the most practical option: QR codes. The basic idea was to give each user a unique QR code, much like a Naver QR-code login, and let a scanner read it.

#### Choosing the stack

- **Frontend**: Vanilla HTML
- **Backend**: Express.js & Node.js
- **Database**: MongoDB
- **Authentication/security**: JWT & bcrypt
- **UI/styling**: Tailwind CSS

I relied heavily on Claude 3.5 Sonnet during development. I designed the backend flow first and then connected the frontend to it. I considered React, but finishing quickly mattered more at the time, so I chose Vanilla HTML.

### 2. Development

![The file structure of the digital attendance project](/images/pr6.png)

```
📁 project root
├── 📁 css
├── 📁 js
├── 📁 node_modules
├── 📄 change-password.html
├── 📄 dashboard.html
├── 📄 find-password.html
├── 📄 hub.html
├── 📄 index.html
├── 📄 package.json
├── 📄 package-lock.json
├── 📄 qr.html
├── 📄 reader.html
├── 📄 signup.html
├── 📄 statistics-dashboard.html
└── 📄 tailwind.config.js
```

The structure was roughly as follows:

- `index.html`: login page
- `hub.html`: routes users based on their permissions
  - regular users: automatically redirected to `qr.html`
  - admin/reader users: choose a menu on the hub page
- `qr.html`: displays an encrypted QR code that refreshes every 30 seconds
- `reader.html`: QR-code scanning page

![The administrator dashboard for approving users and managing permissions](/images/관리자페이지.png)

The administrator dashboard handled user approval and permission management.

![A dashboard showing attendance and individual student statistics](/images/11.png)

The statistics dashboard received the most attention. It showed the overall attendance status and detailed statistics for each student.

![The attendance screen for handling approved absences](/images/22.png)

Special cases, such as sick leave, could be recorded as approved attendance.

![The attendance screen connected to the NEIS academic calendar](/images/33.png)

I connected the NEIS academic calendar API so weekends and holidays were handled automatically.

![The screen for attendance cutoffs and automatic absence handling](/images/44.png)

I also added settings for the cutoff times for attendance, lateness, and absence. If no record existed after the cutoff, the system marked the student absent automatically.

I also built a hybrid app with React Native.

![The hybrid attendance app built with React Native](/images/앱.png)

### 3. Looking back

I piloted the system in my class from September to December 2024 and confirmed that it worked reasonably well. While building it, I thought feature implementation would be the hardest part. Operating it taught me that small policies—user approval, exception handling, and cutoff times—mattered much more.

I could not release the app immediately because of age restrictions at the time, but the project gave me direct experience solving a real problem at school with software.

<YouTubeEmbed id="uVYktO-Xy3U" title="Digital attendance system overview" />


How I built and piloted a QR-based attendance system to reduce manual attendance work at school.

Building a Digital School Attendance System


# 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

Transformers are an important foundation, but their limits are clear. Attention cost climbs sharply as the sequence gets longer, so people keep trying to solve that a different way. MoE goes after raw computation; the SSM family goes after the cost that grows with sequence length.

MoE (Mixture of Experts) keeps several expert models around and activates only the ones an input needs, instead of making a single model do every calculation.

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

`g_i(x)` is the gating function that picks the experts and `f_i(x)` is each expert's output. The point is to run a larger model while cutting computation and memory.

There is also the hyperscale direction, growing the model and the computing system together. Simplified, performance can be read as a scaling law:

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

`N` is the parameter count, `C` is computing power, and alpha and beta are scaling coefficients. But the cost grows with it, which is why structural efficiency work like the SSM family below runs in parallel.

## New Architectures

### SSM (State Space Model)

SSMs come up often 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, and memory use drops below a transformer's, which helps on long inputs.

### Mamba

Mamba builds on SSMs with a selective state-update mechanism.

<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 takes hardware optimisation into account too. It is said to be particularly good at long contexts.

### Jamba and Hybrid Structures

Jamba is a hybrid that mixes the strengths of transformers and Mamba. Simplified:

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

It has 120B active parameters and goes after throughput and long-sequence handling at the same time, using transformer parallelism alongside Mamba's sequence efficiency.

## Complexity, and What I Still Wonder About

The architectures above already split on computational complexity.

- Transformers are limited on long sequences by `O(n^2)`.
- SSMs and Mamba process in linear `O(n)`, so they handle length more efficiently.
- Jamba aims at `O(n log n)`, balancing efficiency against performance.

Two things I am still curious about. One is real-time processing. Latency, simplified, looks like this:

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

If that improves, LLMs fit more naturally into real-time applications. The other is multimodality — AI moving past text alone into images, audio and interaction:

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

Which is roughly the direction of how a person uses several senses at once. Making models bigger does not settle either problem on its own, so compute efficiency and architecture itself stay on the table.

# 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.

Why Do LLMs Get Easy Things Wrong?


# Using Generative AI to Help Write Student Records

Since ChatGPT appeared, people have increasingly used generative AI as a writing assistant. I think AI can help with *se-teuk*, the subject-specific remarks in Korean student records.

That does not mean AI should write a student's record by itself. Teachers should organize their own materials, the student's real activities, and their usual writing style. AI is better used to draft from that material.

The biggest danger is hallucination. AI can invent plausible details that the user never provided. For a fact-based document such as a student record, that is especially risky. Clear instructions such as “do not write anything that is not in the materials,” followed by careful review, are essential.

I usually recommend Anthropic's Claude. Its web interface felt unfamiliar at first, but I found it good at polishing long Korean passages. ChatGPT can be used in a similar way. Paid models cost roughly a few tens of thousands of won per month. Free models are possible, but for important documents I would prioritize quality and reviewability.

Prompts matter. A prompt is an instruction manual for the AI: explain the role, the standards it must follow, and which materials it may use.

![Creating a new project in Claude](/images/image.png)

Create a project in Claude so reference materials and instructions stay together for repeated work.

![Adding reference materials to Claude Project Knowledge](/images/image1.png)

Project Knowledge is important. Add the teacher's usual student-record style, sentence structures, and reference materials. OCR-capable PDFs are more reliable than image-only files. I used *How to Write School Records* from the Jeju College Admissions Council as an example, but it is better to split very large files into smaller sections.

Before asking for subject remarks, write the project instruction. For example:

> You are a high-school teacher experienced in writing student records. Write subject-specific remarks using only the provided student information. Keep each subject under 500 Korean characters, use objective and concrete descriptions, focus on growth and learning, include real class or activity examples, and avoid unsupported praise, prior-learning content, or material that encourages private tutoring.

Then add the student's materials with **Add Content**.

![Adding materials to a conversation](/images/image3.png)

The most important instruction is to say clearly: “Do not write anything that is not in my materials.” That sentence reduces hallucinations considerably.

![An example prompt asking the AI not to invent details](/images/image6.png)

If the draft feels weak, add another example in the relevant subject to establish the style.

![A conversation improving a draft with another example](/images/image7.png)

The same approach works for general student remarks. Organize the student's traits, activity keywords, and concrete examples, let AI structure them first, and then ask it to polish around those facts.

Start a new chat for each student. Otherwise information from the previous student can leak into the next draft. Claude's usage can also run out quickly, while ChatGPT may offer more generous usage or convenient search. Choosing tools based on the situation is reasonable.

The key is not which AI you choose, but how well you organize and review the source material. AI is more stable as a drafting assistant than as a replacement writer.


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

Using Generative AI to Help Write Student Records


I wrote this after watching Eric Schmidt discuss AI around September 2024. The mood around AI can change in a few months, so parts of it may already feel dated. I still want to keep what caught my attention at that moment.

![Cover image for a post about Eric Schmidt's AI interview](/images/3.png)

# The Rapid Progress of AI

Schmidt said AI is changing so quickly that we may need a new interview every six months. It can sound exaggerated, but the period since ChatGPT makes the point feel reasonable.

What stayed with me was the discussion of million-token context windows, AI agents, and Text to Action. Text to Action still seems especially interesting: if a spoken instruction can lead all the way to an actual task, the way we use computers could change significantly.

# Why AI Infrastructure Matters

Schmidt emphasizes that AI needs enormous investment, especially hardware infrastructure such as NVIDIA GPUs.

> “NVIDIA became a two-trillion-dollar company because most code has to run on CUDA optimized for NVIDIA GPUs.”

That made me realize that AI is not only about building a good model. GPUs, electricity, data centers, and CUDA have to move together underneath it.

# AI's Social Impact

Schmidt thinks AI could have a larger social impact than social media. That idea stayed with me. Social media changed relationships and how we consume information; AI could change how we study, work, and make decisions.

# International Competition

AI is not only a competition between companies. It is also a competition between countries, especially the United States and China. That competition may accelerate progress, but it could also widen the gap between countries that can use AI and those that cannot.

# My View

Schmidt's argument leans toward AI's possibilities. I like AI and use it often, but there are too many unresolved questions for simple optimism: whether its decisions are fair, how bias is handled, how jobs change, and how personal data should be processed.

As Schmidt also suggested, AI may become a game dominated by wealthy countries. I keep wondering how that gap could be reduced.

# Closing Thoughts

The interview reminded me that AI cannot be reduced to “good” or “dangerous.” It is one of the most interesting technologies I can learn by using and building, but it also raises questions society has to answer together.

I want to keep testing AI instead of praising it from a distance, and record which parts are genuinely useful and which parts are risky.


What an interview with Eric Schmidt made me think about infrastructure, national competition, and social change.

Eric Schmidt on the Future of AI


As AI has developed quickly, one trend has caught my attention more than most: open-source AI. At first, I thought it simply meant making a model public. Then I ran Llama locally, and the idea felt very different. Experiments that seemed reserved for large companies suddenly became something I could try with my own hands.

![The cover image for a post about open-source AI](/images/2.webp)

# The Vision of Open-Source AI

Recently, I read Mark Zuckerberg's [“Open-source AI is the path forward”](https://about.fb.com/news/2024/07/open-source-ai-is-the-path-forward/) and watched the [related video](https://www.youtube.com/watch?v=1jCESAqhUJU&t=1s). It is Meta's argument, so it naturally includes some company strategy, but a lot of it made sense from an individual developer's perspective.

The core idea is simple. When an AI model is public, more people can experiment with it, improve it, and adapt it to their own situations. That is much bigger than simply using something for free.

# Why Open Source Matters in AI

The biggest advantage of open-source AI is access. Startups, researchers, and individual developers can work with models directly instead of depending entirely on expensive API calls or closed environments.

Transparency and trust matter too. When a model is public, the AI community can inspect the code, understand how it works, and examine its safety and ethical issues together.

Another strength is the way developers around the world experiment in parallel. Someone improves inference speed. Someone else makes a model run on a smaller GPU. Another person tests its Korean performance. That kind of ecosystem grows differently from a closed model.

As Zuckerberg pointed out, running inference with an open-source model such as Llama 3.1 can be much more cost-effective than using a closed model.

# My Experience with Open-Source AI

The power of open-source AI is not just a theory to me. I tried it myself. I ran Llama 3.1, which was often described as having performance comparable to GPT-3.5 Turbo, on my own computer. Seeing it run for the first time was genuinely exciting.

It was not always as fast or convenient as a commercial model. Still, I could run the model on my hardware, enter a prompt, and inspect the result. I remember thinking, “I can actually try this myself now.”

I enjoyed the experience enough to demonstrate Llama 3.1 at a school festival. More friends showed interest than I expected. It gave me a chance to show that AI was not just a distant technology in the news; it was a tool people could touch and explore.

# The Future of Open-Source AI

I expect open-source AI to keep growing. As models such as Llama improve, individuals and small teams will be able to build a wider range of services.

It matters especially in education. A student who runs a model, watches it fail, and changes it learns something very different from someone who only consumes AI as a finished product. Those experiences also made AI feel more like a practical technology to me.

# Closing Thoughts

Open-source AI gave me the feeling that I could try something myself. Not everyone can build a giant AI company, but using a public model to solve a personal problem is becoming easier.

There was something funny about the line of friends in front of the laptop running Llama at the school festival. The question I got most that day was whether it still worked with the internet off. It did, and that was the part everyone found strange.


Running open-source AI such as Llama myself showed me what becomes possible for an individual developer.

The Power of Open-Source AI


# My Programming Journey

Hello. This was the first post I wrote after building my portfolio site, Sungblab. I want to trace how I went from a student who loved hardware to someone interested in web development and AI.

# The Early Sungblab

I had already used the name Sungblab before this site. In eighth grade, I made a site with basic HTML and Bootstrap. The layout was strange and the content was thin, but I was proud simply because I had built a website myself.

![The first Sungblab website made with Bootstrap in middle school](/images/1.png)

# A Childhood Curiosity about Technology

My story began even earlier. I loved hardware as a child, taking apart and rebuilding toys and machines around the house. If my parents gave me a flip phone, I could hold it all day. A friend even remembers me drawing a laptop in a sketchbook and pretending to type on it in kindergarten.

# Growing Up with Smartphones

I got my first smartphone in third grade: a SIM-free Samsung Galaxy S2 with about 16GB of storage. My next phone was a Galaxy Note 3, and that was when I started experimenting with custom ROMs, TWRP, and rooting. In fifth grade I got a Galaxy S7 Edge and tried rooting and overclocking during the last period when custom ROMs were especially popular.

# Discovering Computer Hardware

I also wanted a computer badly. In fourth grade I used my siblings' computer, which had something like an Intel Celeron G1850. In fifth grade, I saved allowance to secretly buy a GTX 1050 Ti for 120,000 won, an i5-4690, and two 8GB RAM sticks so I could play PUBG. Later I built systems with a Ryzen 5 3500X and GTX 1660, then a Ryzen 5 5600X and RTX 3070. I never visited a computer shop; I researched and fixed everything online, sometimes helping friends with their computers too.

# Seeing ChatGPT in My Last Year of Middle School

Until middle school I was mainly interested in hardware. That changed in ninth grade, when ChatGPT was first released to the public in 2022. It felt like seeing a new world. I started making websites and wondered whether software and AI might offer an even more interesting future.

# I Wanted to Make Games and Ended Up on the Web

I originally started programming because I wanted to make games. Unreal Engine, the Windows API, and C++ were too difficult to start with, so I moved to the web. In high school I began working seriously with Python and web development.

# Now and Next

In my first year of high school, I used ChatGPT in daily life and while coding, and became more interested. In 2024 I founded the Codelab programming club and built projects with its members. You can see them on the [club website](https://codelap.netlify.app).

I was not initially interested in React or Next.js. I simply liked HTML. But after using Django and Flask on the backend, I decided to try React. The [“React is the best” song by Coding Apple](https://youtu.be/pVQPfTleC_4?si=lH7tzUE2gQfzdnNY) helped convince me. When I learned that Next.js supported SSR, I decided to use it for this portfolio and blog.

# Meeting AI

Claude made coding and learning more convenient, and I also started using AI in daily life. Experimenting with Meta's Llama led me to imagine a future working with software and artificial intelligence.

# Closing

Looking back, I started with the curiosity to take apart hardware, moved through web development, and now combine AI with modern web technologies. This site is a result of that process and a place to record what I build and learn next.

There is still plenty to improve, but I want to keep growing by building things directly, failing, and fixing them again.


My journey from taking apart hardware as a child to becoming interested in web development and AI.

Blog