
# I Don't Vibe-Code on Instinct Alone

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.


The routine I developed while building with AI agents: document structure, a skills harness, small slices, and verification loops matter more than prompts alone.

How I Do Vibe Coding


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


# 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 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]
```

#### What I changed while refining the prompt

1. **Stronger context**: structured student information, connected related facts, and placed information in a useful timeline.
2. **Better responses**: added concrete guidelines, a consistent response structure, and an emphasis on actionable advice.
3. **More personalization**: considered MBTI, learning style, and individual strengths and weaknesses.
4. **Practicality**: added concrete actions, time-based goals, and achievable steps.

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

<div
  style={{
    position: "relative",
    paddingBottom: "56.25%",
    height: 0,
    overflow: "hidden",
    maxWidth: "100%",
    marginTop: "2rem",
  }}
>
  <iframe
    style={{
      position: "absolute",
      top: 0,
      left: 0,
      width: "100%",
      height: "100%",
    }}
    src="https://www.youtube.com/embed/6ptUPSYBBtA"
    title="Career counseling chatbot using Claude API and Flask"
    frameBorder="0"
    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
    allowFullScreen
  ></iframe>
</div>

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


# Deleting Two Projects

Today, I deleted UnivMind and OpenCairn.

I took down the servers and removed the repositories from GitHub. I could have left them there. But I did not want to keep projects online when they were difficult to explain, even to myself, or when their behavior felt uncertain.

I also kept thinking about how those projects might look to someone visiting my GitHub. They could easily become the standard by which people judged what I had built.

I did not like that.

## UnivMind

UnivMind was an AI learning service for university students.

I assumed that university course materials would be scattered across PDFs, slide decks, announcements, and documents. They were. During exam season, finding the material, organizing it, and understanding it again becomes work in its own right.

I wanted students to upload their materials, organize them with AI, ask questions, and study in one place.

UnivMind worked.

It was not a completely 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 that UnivMind worked, but it 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.

The implementation did not keep up.

The agent I considered central never worked reliably enough. 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 was a different kind of failure from UnivMind.

UnivMind worked but felt thin. OpenCairn had a large vision but did not work well enough.

One was a product I could build without a strong reason for people to use. The other had a large direction, but the implementation could not follow it.

## 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 by myself. If I have an idea, I can turn it into a service.

UnivMind and OpenCairn changed that feeling a little.

Building became easier.

Creating a reason for people to use something did not become 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 has also made it possible for more people to build similar products faster.

That is why I think choosing the problem matters more than implementing another feature.

What problem are we solving? Is it strong enough? Who pays? Why now? Why me? What is the moat? How deeply does the product enter a customer's workflow or tacit knowledge?

Those questions matter more now.

## Deleted, But Not Gone

I deleted UnivMind and OpenCairn.

But I do not think they disappeared completely.

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. Both were experiments that changed how I judge what to build.

I used to ask whether I could build something. Now I want to ask why I should build it.

I used to think adding features was how a product came together. Now I pay more attention to the strength of the problem and the user's context.

I used to find the ability to build something with AI exciting in itself. Now that AI makes building easier, I think choosing the problem carefully matters even more.

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

I still do not have a complete answer about what comes next. But one thing is clear.

Next time, I want to build something smaller. I want to start with a more concrete problem.

I want to look for problems that actually reduce someone's money, time, or repetitive work, rather than visions that merely look impressive.

I want to build a product people have a real reason to use, rather than a polished AI product that is only 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


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

Both speakers discuss AI and future industries at a huge scale. What interested me was that the conversation kept returning to a simple question: which problem are we actually trying 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.

## Longevity and Quality of Life

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.

## Entrepreneurship and Innovation

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.

## Running a Company

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.

## Sources

1. Startup Grind Global Conference conversation, referenced through a BZCF translation.
2. Tesla's official blog.
3. SpaceX Mars project documents.
4. Y Combinator blog.
5. OpenAI research materials.

## Further Reading

- *Elon Musk* by Walter Isaacson
- Sam Altman's blog posts
- Documentaries about Tesla and SpaceX
- OpenAI's technical roadmaps


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


# 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 Performance Optimization

Real-time camera processing was heavier than expected, so I added several optimizations:

1. Process recognition every three frames and resize each frame to one quarter size.
2. Use HOG-based detection for CPU-friendly recognition and vectorized distance calculations.
3. Release unnecessary image objects promptly to keep memory use under control.
4. Keep the UI responsive through asynchronous work and lightweight animations.

### 3.6 Error Handling

For real use, I also needed to handle failures:

1. Try several camera indexes and show a useful message when connection fails.
2. Degrade gracefully when recognition fails, while logging errors and giving user feedback.
3. Check file permissions and handle duplicate files.
4. Prevent leaks when processing large images and release resources correctly.

## 4. How to Use the System

### 4.1 Initial setup

1. Run the program.
2. Register faces in the management tab.
3. Open the attendance tab and start the system.

### 4.2 Daily use

1. Start the program.
2. Click **Start Attendance**.
3. Let the system recognize faces and record attendance automatically.
4. Export attendance records when needed.

### 4.3 Management

1. Register new faces.
2. Manage existing face information.
3. Manage and back up attendance records.

## 5. Limitations and Improvement Plan

### 5.1 Features

- Improve recognition accuracy with a deep-learning model
- Add real-time statistics and charts
- Connect a database
- Add a web interface

### 5.2 Performance

- Add GPU acceleration
- Improve multithreaded processing
- Optimize memory use

### 5.3 User experience

- Make the UI/UX more intuitive
- Add multilingual support
- Add customization options

The full source is available on [GitHub](https://github.com/Sungblab/SB_face_recognition_system). If I rebuilt it now, I would separate the code more carefully and design more thorough recognition tests and registration flows. This project taught me that computer vision is not only a model problem; the real usage flow has to be designed too.

<div
  style={{ position: "relative", paddingBottom: "56.25%", height: 0, overflow: "hidden", maxWidth: "100%", marginTop: "2rem" }}
>
  <iframe
    style={{ position: "absolute", top: 0, left: 0, width: "100%", height: "100%" }}
    src="https://www.youtube.com/embed/OEV1jFOZ5-4"
    title="Building a face-recognition attendance system with Python"
    frameBorder="0"
    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
    allowFullScreen
  ></iframe>
</div>


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?

In the tests I reviewed, translation without context reached about 70% accuracy, while providing appropriate context raised it to about 95%. This resembles language learning: a word is easier to understand and remember in a real conversation than in isolation.

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

The experiments showed strong results for simple and complex tense, active/passive voice, SVO and SV sentence structures, and context-sensitive articles. The model also distinguished meanings such as “bank” in “I went to the bank to withdraw money” and “the bank of the river.” In the tests, providing context improved accuracy by about 40% on average.

## 6. What I Learned

The interesting part was that the translator did not look at one word alone. It used the surrounding context. It handled “I go to school” and “I went to school” with 100% accuracy in the test, and analyzed “I have been studying English for 3 years” with more than 95% accuracy. It also recognized that “The group of students is studying” takes a singular verb.

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

AI translators are becoming more than sentence-conversion tools. They can explain grammar, compare context, and suggest natural expressions. They are useful for learning, but they are not always correct. I prefer asking why a correction was made and comparing it myself instead of accepting the answer blindly.

AI is closer to a tool that makes studying faster and more concrete than a replacement for a teacher or learner.

## References

1. Vaswani, A., et al. (2017). “Attention is All You Need.”
2. Devlin, J., et al. (2019). “BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding.”
3. Brown, T. B., et al. (2020). “Language Models are Few-Shot Learners.”
4. Kim, J., & Lee, S. (2023). “The Impact of AI Translation on Language Education.”
5. Park, M., et al. (2024). “Context-Aware Translation Systems in Educational Settings.”


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

How Do AI Translators Understand Grammar?


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

## Netflix's Company Culture

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.

## Growing Through a Crisis

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.

## Sam Altman's Startup Principles

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.

## The Reality of Being a Startup CEO

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.

## Global Strategy and the Core of Success

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


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

# Turning toward Software

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.

# Moving into Web Development

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.

My Programming Journey


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

<div
  style={{
    position: "relative",
    paddingBottom: "56.25%",
    height: 0,
    overflow: "hidden",
    maxWidth: "100%",
    marginTop: "2rem",
  }}
>
  <iframe
    style={{
      position: "absolute",
      top: 0,
      left: 0,
      width: "100%",
      height: "100%",
    }}
    src="https://www.youtube.com/embed/uVYktO-Xy3U"
    title="Digital attendance system overview"
    frameBorder="0"
    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
    allowFullScreen
  ></iframe>
</div>


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

Building a Digital School Attendance System


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.

I do not want to keep open-source models at a distance. I want to run them, connect them to services, and keep testing what they can actually do.


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

The Power of Open-Source AI


# 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. I do not think we can keep up by watching from the sidelines.

How should we prepare? I think the most important thing is the habit of continuing to learn. 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. We also need to ask who is responsible for an AI decision, and what should happen when something goes wrong in areas such as autonomous driving or medical AI.

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

I feel that we are at an important turning point. I do not know exactly when the singularity will arrive, but AI is already changing how we study, develop, and work. I want to keep following that change by building and learning directly, rather than treating it as someone else's story.

## References

1. Kurzweil, Ray. (2005). *The Singularity Is Near: When Humans Transcend Biology*. Viking.
2. Bostrom, Nick. (2014). *Superintelligence: Paths, Dangers, Strategies*. Oxford University Press.
3. Ford, Martin. (2015). *Rise of the Robots: Technology and the Threat of a Jobless Future*. Basic Books.
4. Tegmark, Max. (2017). *Life 3.0: Being Human in the Age of Artificial Intelligence*. Knopf.


Thinking about the idea of the singularity made me consider how we should prepare for change in the age of AI.

The Singularity Is Coming


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

Turning What I Don't Know into Questions


# 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


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

Blog