Development Automation with Claude Code—from Consoles to GUIs, 3D, and Web Applications

This course is a practical program on using Claude not merely as a chatbot that answers questions, but as a collaborative partner that works alongside you on real tasks. It consists of 2 parts and 18 lessons in total. First, we cover the basic principles of how generative AI understands and generates language—including semantic analysis, ambiguity, and statistical language models—to lay the foundation for using Claude effectively. With this understanding, you will be able to design more sophisticated prompts. Next, we automate the tasks you encounter every day in your work, one by one. From automatically organizing emails, extracting action items from meeting minutes, and cleaning up Excel data to writing reports and proposals, extracting information from invoices and receipts, and automating daily briefings, the course covers a broad range of document and data-related tasks. In the latter part, we take things a step further. Through hands-on practice, you will learn to automatically generate PPT slides, integrate external services, create schedule-based automated routines, use Skills plugins, conduct parallel competitor analyses, write SOPs and internal policies, automate the Chrome browser, and even build real apps through vibe coding. Beyond simple question-and-answer interactions, you will develop practical expertise in working with Claude—from requirements analysis and documentation to automation and development.

This course is a 37-lesson, approximately 14-hour program that covers OpenAI’s AI coding agent, Codex, from start to finish. AI coding tools are now commonplace. However, most users remain at the level of accepting autocomplete suggestions or asking questions in a chat window. Agentic tools like Codex can do much more than that. They can read an entire project, modify multiple files simultaneously, run tests, and find and fix errors on their own. The problem is that they require an equivalent level of control. If you do not know what to allow and what to block, or how to teach the tool your project’s rules, you will end up cleaning up the code it creates afterward. This course focuses on how to establish that control. In the beginner section, you will learn installation and your first conversations, file editing and session management, and slash commands, while building a foundation in prompt writing. Through hands-on practice, you will internalize three principles: making clear requests, breaking down tasks, and verifying the results. The intermediate section is where the main content begins. You will configure behavior with config.toml, teach project rules with AGENTS.md, and manage memories with Memories. You will design safety boundaries yourself by combining the sandbox with four types of approval policies. The course then covers thread separation and parallel work, planning mode, connecting MCP servers, and creating custom skills based on SKILL.md. Finally, after covering web searches and Git automation, VS Code and Cursor integration, and hands-on FastAPI practice, you will examine Codex’s internal protocol, the SQ/EQ queue model. Understanding how the tool works changes how you respond when problems arise. The entire course follows the process of building a single service called TaskFlow. Rather than learning each feature in isolation, you will experience, in sequence, when and why each one is needed in a real project.

This course covers the fundamentals of Docker in 7 lessons totaling 3 hours and 55 minutes. Rather than stopping at conceptual explanations, you will write and build 5 Dockerfiles yourself. By the end, you will combine a FastAPI server and a MySQL database into a single application and run it with one line: docker compose up. Lessons 1 and 2 begin with installing Docker Desktop and checking the WSL2 environment. You will pull an ubuntu image from Docker Hub and confirm that images are composed of multiple layers, then manage local images with images and rmi. Next, you will work with the container lifecycle using run, ps, stop, and rm, and use exec to enter a running container. You will open an httpd container’s web page in a browser through port mapping (-p), then start a MySQL container with a volume (-v) and environment variables (-e) to see why data remains even after the container is deleted. Lessons 3 through 5 focus on creating images yourself. You will examine FROM, WORKDIR, COPY, ENV, RUN, CMD, and EXPOSE line by line, highlighting the difference between RUN and CMD: RUN operates at build time, while CMD operates at runtime. You will create images for four different types: a Python script that runs once and exits, a continuously running FastAPI server, an executable compiled with PyInstaller, and an existing binary such as jq. In the compilation example in particular, you will use a multi-stage build to discard the build tools and keep only the final output. Lessons 6 and 7 focus on connecting containers. First, you will reproduce the "Internal Server Error" that occurs when two containers are started without network configuration. Then, you will create a network with docker network create so that the containers can find each other using only their names. You will check the assigned IP addresses with network inspect and even visually confirm that Docker’s built-in DNS (127.0.0.11) is working by using ping and /etc/resolv . conf inside a container. In the final lesson, Lesson 7, you will transfer all the docker run options covered so far into a single compose.yaml file, then bring up and shut down the entire application with up and down. The five types of project materials used in the exercises—including Dockerfile, app . py, and compose.yaml—are provided, so you can follow along immediately without typing. The exercises are conducted in a Windows + PowerShell environment, and the commands are the same on macOS and Linux.

This course is a hands-on program designed to systematically teach the core features of Claude and Google Gemini 3.1, the two most prominent AI platforms as of 2026. The first half begins with the basics of using Claude AI and covers, step by step, the four essential elements of writing effective prompts, the Artifacts feature for automatically generating documents, tables, and charts, and how to create your own customized AI assistant using the Projects feature. You will also learn file-processing capabilities that can be used immediately in real-world work, including image analysis and PDF summarization. The second half compares the differences among the three latest Gemini 3.1 models—the fast model, the thinking model, and Pro—and teaches you how to write documents and code using Canvas, as well as how to generate reliable reports through Deep Research. It also broadly covers realistic image generation and text-rendering techniques with Nano Banana 2; AI video production using Veo 3.1 and Flow; source-based analysis and AI-generated audio and slides with NotebookLM; real-time camera conversations through Gemini Live on smartphones; creating expert assistants with Gems; and Gemma 4, a locally installable AI. Each section includes hands-on prompts and demonstrations, allowing you to apply what you learn immediately to your work and daily life. From beginners encountering AI for the first time to existing users, this comprehensive course enables you to master the latest features of both platforms in one program.

This course consists of 47 lessons, totaling approximately 39 hours, in which you build deep learning from the ground up with PyTorch. There are many deep learning courses, but most fall into one of two categories. Either they skim only the basics of using libraries, leaving you unsure why the code is written the way it is, or they start with equations and leave you giving up halfway through. This course takes a different approach. First, you create a result; then you dig into what happened under the hood. The course begins with pretrained models. You will run image classification, try inpainting with Stable Diffusion, and even practice image captioning with BLIP. Because you produce tangible results from the very first lesson, you gain the motivation to learn the theory that follows. Next comes the core of this course. Tensors are covered over seven lessons. In addition to indexing and broadcasting, you will explore memory structures such as storage and strides, memory contiguity management, GPU operations, and conversions between tensors and NumPy arrays. It is rare to find a Korean-language course that covers tensors in this much depth. Once you understand this part, you will read all subsequent code differently. You will then learn preprocessing that converts real-world data into tensors. The course covers different data types, including image color channels, tabular data and one-hot encoding, time series, and text embeddings. Moving on to the principles of training, you will implement loss functions and gradient descent yourself using numerical differentiation, and then see how Autograd automates the process. Only those who have built it themselves can truly appreciate the convenience of automatic differentiation. The second half focuses on neural network architectures. You will build deep neural networks with nn.Module and classify CIFAR-10, encounter the limitations of fully connected neural networks, and naturally arrive at why CNNs are necessary. Finally, you will move on to text generation, covering everything from bigram models to embeddings and MLP-based generative models, and then the principles of Attention’s Query, Key, and Value. If you know how to use Python and want to properly understand deep learning, what you will take away from this course is not example code, but the ability to read and understand the structure of any model you encounter.

This course consists of 41 lessons and approximately 22 hours of training on designing and implementing backend APIs with FastAPI. FastAPI is a framework that is easy to get started with. Skim the documentation, write a few lines, and your API is up and running. The problem comes afterward. If you don’t know how a request travels to reach a function parameter, when dependencies are cleaned up, or where exceptions are caught, you can quickly get stuck as soon as things become even slightly more complex. This course spends time tracing how things work internally. We begin with the development environment. You’ll learn both conda and venv, send requests using the VS Code REST Client and Swagger UI, and become familiar with the structure of HTTP requests and responses. Next, we cover the difference between path parameters and query parameters, explaining why 422 errors occur in connection with type checking. Pydantic is the area explored most deeply in this course. After covering everything from scalar types to dates, UUIDs, Decimal, Enum, and Literal, we move on to BaseModel. We use Field() to define constraints, validate single and multiple fields with @field_validator, and examine the differences between the before and after behaviors of @model_validator. Since the course is based on Pydantic v2, you can apply the latest syntax directly in real-world projects. The middle section focuses on structure and dependency injection. We cover how to split files using APIRouter, how to use functions and classes as dependencies, Sub-dependencies, and decorator-level dependencies in sequence. Four lessons are dedicated to yield. We delve into how generators work, how exceptions are passed back up the call stack with raise, and how exceptions can be injected at the yield point using throw(). Understanding how resource cleanup works in dependencies that include yield makes DB session management much clearer. The latter part covers authentication and databases. We organize the concepts of OAuth 2.0 and its four Grant Types, then implement JWT issuance and verification, the internal execution logic of OAuth2PasswordBearer, and authorization control using Security() and scopes. We then configure Google, Kakao, and Naver clients ourselves and add social login using the Authorization Code Grant flow. Finally, we cover the SQLAlchemy ORM, including the URL structure of create_engine, the roles of the Dialect and DBAPI, transactions, sessions, and model and table creation. This course is suitable for anyone who wants to understand not only "working code" but also "why it works that way.&quot

When you look back on a day at work, certain tasks repeat themselves. You search for information, write reports, attend meetings and take notes, create Excel spreadsheets and PowerPoint presentations, and organize and share the results in documents. These five tasks are essentially the backbone of office work. This course covers those five stages in order, assigning one suitable AI tool to each. Perplexity is used for research and organizing information, Claude for writing documents and creating drafts, Naver ClovaNote for automating meeting minutes, Microsoft Copilot for support with office tasks, and Google Gemini for integration with Google services. This is not a course that simply lists tools; it teaches you how to decide which tool to insert at which point in your workflow. Each tool is covered in the same three-step format. In Lesson 1, you will learn the background behind the tool, what it does well and poorly, and where the boundary lies between its free and paid plans, before taking a look around the official website. In Lesson 2, you will learn the basics by going through the menus and settings. In Lesson 3, you will practice using real-world work scenarios. Examples include creating business and business-trip report templates, researching popular restaurants in Jongno, Seoul and organizing the information into promotional presentation materials, drafting a business report PPT introducing a product to a client, recording a sales report meeting and turning it into meeting minutes, creating a marketing logo image, and preparing approval forms and accounting ledgers in Google Docs. In particular, this course spends considerable time showing how much the results can vary depending on how you phrase your questions. You will see firsthand that even the same request can produce completely different results when written in two lines versus ten, using specific instructions such as generating tables, creating charts, specifying list formats, and downloading files. All you need is a PC connected to the internet and a web browser. You will need to sign up for each of the five services, and the course is based on their free usage options. However, each tool has different limitations. Microsoft Copilot becomes especially useful when integrated with Office applications, so its value increases significantly in an environment that uses Microsoft Office. For real-time recording practice with ClovaNote, the mobile app is more reliable than a PC microphone. These details will be explained as they come up in the relevant sections. It is perfectly fine if you have never used an AI tool before. By the end of the course, you will be able to decide, "Which tool should I open for this task?" and formulate questions on your own to get the results you want.

This course is a 26-session, approximately 13-hour hands-on course for those opening Figma for the first time, covering everything from the fundamentals of UI design to the latest AI automation features. Figma has now become an essential tool for UI design, but with so many features, it can be overwhelming to know where to start. In particular, if you do not properly understand concepts like Auto Layout and Components, you will keep taking workarounds and ultimately remain stuck manually moving shapes one by one. This course builds up these concepts step by step through examples. The first part covers the interface, vector tools, and graphic styles. Once you learn how to work with shapes and paths and register color and text styles as a system, your workflow speed will change. You will then learn the principles of automatically arranging elements with Auto Layout. The middle section focuses on Components and Variants. You will practice creating a single button, managing its different states, and building a structure that can be reused across multiple screens. In the responsive layout sessions, you will learn to design UIs that do not break when the screen size changes and extend them to mobile layouts. The final six sessions are what set this course apart. You will learn how to import existing web pages into Figma using the 'html . to . design' plugin, turn designs into actual web pages with Figma Site, and generate code by entering prompts with Figma Make. The latest Figma AI features are also covered. You can follow along even if you did not major in design or have never used graphic tools before. By the end of the course, you will be able to design web and mobile UIs yourself and reduce your working time with AI features.

This course is an introduction to vibe coding, where you can develop programs simply by asking questions, without any coding knowledge, using Antigravity 2.0, Google’s AI agent development platform. To ensure you can follow along without making any paid purchases, the course makes maximum use of free AI models and consists of 3 parts with a total of 19 lessons. In Part 1, you will learn what Antigravity is. We will examine how IDE and CLI environments differ in AI vibe coding, where Antigravity fits among the various types of AI development tools, and why it is compared to "self-driving." You will complete the installation and launch the first screen, getting ready to begin development. Part 2 covers how to use Antigravity in detail. You will learn how to ask questions, check results, and make revisions while creating your first project, as well as important points to keep in mind when using Undo and Redo, how to use the project menu, and how to stop approval requests from appearing every time. It also includes practical tips for dealing with free model usage limits, enabling you to solve problems on your own when you get stuck. In Part 3, you will implement a feature that integrates Survey data using an external AI. You will learn how to ask questions to get the results you want, review the completed project, and finish by completing the data integration yourself through two hands-on exercises.

This course is a 16-session, approximately 9-hour-and-30-minute practical course for developers with a foundation in Streamlit who want to build web apps ready for real-world deployment. Streamlit is a tool that can display a screen with just a few lines of code. That makes it easy to get started, but when you try to use it in practice, you run into a different set of challenges. How do you add login functionality? Where and how should passwords be stored? How can variables be shared across multiple pages? How do you prevent the entire screen from rerunning every time a form is submitted? This course addresses these challenges one by one. In the first half, you will review dataframes and chart visualizations, date and file-upload widgets, and Session State while building a mini dashboard. You will then begin the first project: an NLP analysis app. After setting up an Anaconda virtual environment and installing spaCy, neattext, wordcloud, and deep_translator, you will complete a single app by adding text statistics, part-of-speech analysis, word-cloud visualization, multilingual translation, and Korean sentiment analysis. You will also learn how to improve the app’s overall quality by structuring the interface with st . columns and st . expander and adding branding to the sidebar. The second half focuses on service-level features. You will manage member data with SQLite, examine the risks of storing passwords in plain text, and securely handle passwords using SHA-256 hashing. The course then covers theme customization, multi-page layouts and URL slugs, passing variables between pages, smart reading that can handle txt, PDF, and docx files, and controlling reloads with st . form and callbacks. The final three sessions cover advanced Python classes. By learning about their internal workings, encapsulation, inheritance, and special methods, you will build a foundation for structuring your code effectively. By the end of the course, you will be able to elevate Streamlit apps from something made “for practice” to something that is genuinely “usable.”