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

Building a School Community Website

How I Do Vibe Coding

Eric Schmidt on the Future of AI

Building a Career Counseling Chatbot with Claude API

Deleting Two Projects

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

Building a Face-Recognition Attendance System with Python

How Do AI Translators Understand Grammar?

My Programming Journey

Building a Digital School Attendance System

The Power of Open-Source AI

The Singularity Is Coming

Turning What I Don't Know into Questions

Using Generative AI to Help Write Student Records

Why Do LLMs Get Easy Things Wrong?


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.

# 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 School Community Website

Choosing the stack

Building the service

1. Planning

2. Development

3. Looking back

Building a Career Counseling Chatbot with Claude API

Eric Schmidt on the Future of AI

Knowledge graph

Contents

Related Posts

Building a Digital School Attendance System

Building a Career Counseling Chatbot with Claude API

Building a Face-Recognition Attendance System with Python