[Claude Code is Over] How to Master Codex at a Professional Level in 1 Hour

If you are using Claude or Claude Code just because everyone else is, please stop immediately. In fact, the quality of all models, including the latest Claude Opus 3.5/4.7 models, has dropped to 2024 levels.

For those who have only touched Claude or Claude Code, please use this article to master Codex in just one hour.

By the way, it is three times more useful than Claude Code.

From YouTube comment analysis to Excel reports, dashboards, and automation.

When using AI tools, you might feel like, "This seems convenient, but I don't know how to use it in actual work."

More people are using ChatGPT to write text, generate ideas, or do a bit of research. On the other hand, not many people are yet using AI to actually create files, run apps, analyze data, and automate weekly tasks.

That's where Codex comes in.

Codex is not just an AI that answers questions. It is an "AI work environment" that treats folders on your computer as workspaces, reads and writes files, creates Excel sheets, builds web apps, verifies operations in a browser, integrates with GitHub and Vercel, and even sets up scheduled executions.

In other words, Codex is less like a chat partner and more like a working partner that gets its hands dirty.

In this article, I will organize the flow of creating a YouTube comment analysis system using Codex in an easy-to-understand way for Japanese users.

Specifically, the flow is as follows:

1. Retrieve YouTube comments.
2. Categorize comments and summarize them in an Excel report.
3. Visualize analysis results on a web dashboard.
4. Save the work procedure as a "Skill."
5. Set up "Automation" so it updates automatically every week.
6. Finally, perform operation verification in the browser.

This might look a bit difficult at first glance. However, once you grasp the concept, it is very simple.

The basics of Codex are: "work inside a folder," "plan before acting," and "save successful procedures in a reusable form."

By mastering these three, your use of Codex will immediately become professional-grade.

Codex is a "Work Environment," Not a "Chat AI"

First, let's organize the basic view of Codex.

For those used to AI like ChatGPT, the Codex screen might look like a normal chat tool at first. There is an input field in the center, and the AI responds when you give instructions. Looking only at this point, it doesn't seem much different from your usual ChatGPT.

However, the essence of Codex is not there.

Codex can treat local folders as work targets. In other words, if you specify a project folder on your computer, it can read, edit, or create new files within it.

For example, you can do the following:

• Create Excel files.
• Read and analyze CSV or JSON.
• Build Next.js or React apps.
• Write Python or Node.js scripts.
• Launch dashboards locally.
• Check screens in a browser.
• Send code to GitHub.
• Publish as a website on Vercel.
• Execute processes periodically.

These are tasks that are difficult to complete with a standard chat AI.

If you ask ChatGPT to "make an Excel file," there are limits to directly integrating files into a project, running them as apps, or verifying them in a browser depending on the environment. On the other hand, Codex is designed from the start for "making," "fixing," "verifying," and "repeating."

Therefore, when using Codex, it's easier to understand if you have the feeling of "entering a workspace with AI" rather than "asking an AI questions."

Projects Start from Folders

When starting work in Codex, the first thing to be conscious of is the project folder.

A project in Codex is basically a single folder on your computer. Inside that folder, configuration files, scripts, Excel sheets, images, app source code, etc., will be placed.

In Codex, you first specify the folder to be worked on. Work progresses while reading and writing files within the folder.

This "folder unit" concept is quite important.

This is because Codex works while looking at the file structure within the folder, not just the chat content. What files are in the project? Where are the settings? Where should output files be saved? Which script should be run to update the report?

Codex understands this information through the folder.

In this example, there is a project folder for YouTube comment analysis, and files and folders like .env.local, agents.md, scripts, outputs, and src are lined up inside.

In an actual project folder, environment variables, scripts, output files, and app source code are gathered together.

With this structure in place, it becomes easier to give instructions to Codex like "update the comment analysis," "fix the dashboard," or "regenerate the Excel sheet."

The folder becomes the foundation of the work. This is the first point to remember when using Codex.

The First Thing to Prepare: agents.md

Once the project folder is ready, the next thing you want to create is agents.md.

agents.md is like a project manual for Codex. If you have used Claude Code, it's easy to think of it as having a role similar to claude.md.

In this file, you write things like:

• What is the purpose of this project?
• What deliverables will be created?
• What kind of data will be handled?
• Which files can be edited?
• Which files contain secret information?
• What rules should be followed during work?
• What checks should be performed upon completion?

With these premises written down, Codex can easily understand the project context even if you start a new chat.

You won't need to explain at length every time: "This is a YouTube comment analysis project, retrieve comments, make an Excel sheet, update the dashboard..."

Of course, you don't need to write a perfect agents.md yourself from the start.

I recommend having Codex create it for you.

For example, ask like this:

"In this project, we will retrieve YouTube comments and create Excel reports and dashboards. Please create a draft of agents.md, including future work rules."

Then Codex will create a file that organizes the project purpose, work policy, directory structure, and points of caution.

A human checks the content and modifies it as necessary. That's enough.

agents.md is not finished once it's created. As you progress, you will learn things like "this method failed," "this is the correct way to call this API," or "the Excel file cannot be updated while it is open."

By adding such content as project memory, Codex will find it easier to avoid the same mistakes next time.

Don't Let It Work Suddenly: Use Plan Mode

A common mistake for beginners using Codex is to suddenly ask it to "make it."

Of course, Codex is quite powerful, so it will proceed to some extent even if it starts working suddenly. However, for tasks involving multiple steps like API integration, Excel generation, dashboard construction, and automation, it is overwhelmingly more stable to make a plan first.

That's where Plan Mode comes in.

Before starting a large task, turn on Plan Mode and organize the work procedure first.

When Plan Mode is on, Codex doesn't edit files or execute commands on its own; it first makes a plan. What steps will it take? What files will it create? Which API will it use? What verification is needed?

It provides these details first.

For a YouTube comment analysis project like this one, you can confirm the following flow in Plan Mode:

1. Retrieve comments using the YouTube Data API.
2. Save retrieved comments as JSON.
3. Categorize comments by category.
4. Determine question comments and reply priority.
5. Generate an Excel report.
6. Format data for the dashboard.
7. Launch the dashboard locally.
8. Check the screen in a browser.
9. Fix any problems.
10. Reflect on GitHub if necessary.
11. Create settings for periodic execution.

By confirming the big picture first, the work is less likely to get messy in the middle.

Especially for business use, Plan Mode is highly valuable. This is because it is more efficient to share the purpose and constraints first than to fix what the AI proceeded with on its own later.

"Make a plan before working."

This is natural in human work, and it's the same with Codex.

Put API Keys and Secrets in .env.local

To retrieve YouTube comments, you use the YouTube Data API. For that, you need to issue an API key on the Google Cloud side and set it in the project.

One thing to be careful about here is the handling of API keys.

Secret information like API keys and access tokens should not be written directly in the code. Also, avoid pasting them into random files like secrets.txt.

Generally, they are saved in environment variable files like .env.local.

Caption: Save secret information like API keys in .env.local. Be careful not to include it in public repositories.

.env.local is used as a local configuration file on the premise that it won't be published to GitHub or elsewhere. Usually, it is included in .gitignore to prevent accidental publication.

When asking Codex, it's good to say:

"Please save the YouTube API key in .env.local. Also check .gitignore to ensure it's not included in GitHub."

Just by adding this one sentence, you can significantly reduce security accidents.

When using it in Japanese companies or for solo businesses, API key management is extremely important. Even for small verification projects, you should get into the habit of saving them in the correct place from the start.

Retrieve YouTube Comments and Convert to Excel

The central deliverable this time is the YouTube comment analysis report.

Instead of just listing comments, we analyze viewer reactions and organize them into a form that can be used for the next action.

Summarize retrieved YouTube comments into an Excel report and visualize trends and question rates by category.

In the Excel report, you can include information such as:

• Number of comments analyzed.
• Number of target videos.
• Percentage of question comments.
• Number of comments requiring a reply.
• Most mentioned tools or themes.
• Percentage by comment category.
• Common question patterns.
• Reply priority.
• Future content ideas.

For example, in the image example, 200 comments are analyzed across 3 videos. The question rate is about 50%, and the most mentioned tool is Claude Code.

This alone provides quite practical insights.

If there are many question comments, viewers might not fully understand the content yet. If the same questions about a theme are repeated, it's worth making a video or article explaining that theme. If a specific tool name appears often, comparison articles or tutorials for that tool might be in demand.

In other words, comment analysis is not just a look back, but material for the next content production.

For YouTube creators, the comment section is a treasure trove. However, reading them all manually takes time. With Codex, you can convert that comment section into analyzable data.

Extracting Frequently Asked Questions

What is particularly valuable in comment analysis is the extraction of question patterns.

What are viewers doubting? Are there many questions for beginners? Are there many comparison questions? Are they stuck on setup or connection methods? Are they worried about fees or limits?

This information is very helpful when thinking about the next broadcast content.

Categorize common questions by theme and convert them into reply policies or angles for the next content.

In the image example, question themes, counts, whether they are for beginners or advanced users, example questions, and reply policies are listed.

For example, you can categorize them as follows:

• General questions.
• How to choose models or tools.
• Setup and connection methods.
• How to build workflows.
• Fees and limits.
• Requests for learning resources.

This can be applied not only to YouTube but to various tasks.

For example, if you run an online course, you can analyze student questions to improve teaching materials. For a SaaS company, you can categorize inquiry content to improve FAQs or help pages. For a sales team, you can categorize questions from prospects to reflect them in proposal materials. For recruitment, you can analyze questions from candidates to improve the recruitment page.

In Japanese workplaces, these voices are scattered in various places like Slack, email, forms, YouTube, X, LINE, and Notion. Using Codex makes it easier to gather and analyze them and turn them into the next measures.

Don't Stop at Excel; Create a Dashboard

Excel reports are convenient, but it can be tedious to open the file and check every time. Therefore, making the analysis results into a web dashboard makes them easier to see.

Caption: Visualize the content analyzed in Excel as a dashboard that can be viewed in a browser.

In the image dashboard, information is displayed in card format, such as:

• Number of analyzed comments.
• Question rate.
• Number of reply candidates.
• Tools attracting attention.
• Distribution of comment categories.
• Insights gained from analysis results.

For example, you can immediately see things like "The center of comments is general feedback, but there are also many questions," "Interest in Claude Code is high," or "You should respond starting from high-priority reply candidates."

This is not just data display. The important point is that it is converted into a form that makes decision-making easy.

For a YouTube creator, which video to make next? For an SNS manager, which question to create a reply post for? For a marketer, which topic to reflect in ads or LPs? For customer support, which FAQ to prepare?

The dashboard is a screen to make those judgments faster.

Verification Possible within Codex's Browser

Once the web dashboard is made, the next thing needed is operation verification.

Normally, a human would launch a local server, open a browser, click the screen, and check for layout collapses or bugs.

In Codex, you can leave much of this verification work to the AI.

You can check the created dashboard as it is in the browser within Codex.

You can request Codex as follows:

"Open the dashboard in the browser and check tab switching, search, links, and display when data is empty. If there are problems, please fix them."

Then Codex will actually open the screen, check it, and propose or execute fixes as needed.

This is quite practical.

When looking only at code, it can be hard to notice UI discomfort. The text on the button is small. The margin of the card is narrow. Nothing is displayed when search results are empty. External links open in the same tab. The selection state of the tab is hard to understand. The layout collapses at mobile width.

These problems are hard to notice unless you actually touch it in a browser.

Using Codex's Browser Use, you can incorporate this verification work into the AI.

Browser Use is Strong for QA

Looking at the Codex plugin screen, functions like Browser Use, Spreadsheets, and Presentations are displayed.

Using Browser Use, Codex can perform screen verification and testing while operating the browser.

Browser Use is not just a function to open a browser. Codex can operate the browser, click, input, and work while checking the screen.

For example, you can do the following:

• Open an app launched locally.
• Switch dashboard tabs.
• Enter text in a search box.
• Check if external links open correctly.
• Press buttons and see the reaction.
• Find layout collapses.
• Check the screen when data is empty.
• Point out accessibility issues.

For developers, this becomes an aid for QA. For non-engineers, the big advantage is being able to use it as an "AI that improves while looking at the screen."

In Japanese business settings, small internal tools or management screens are sometimes used without sufficient testing. By incorporating browser verification into Codex, it becomes easier to find at least elementary bugs or usability issues in advance.

To Improve UI Perfection, You Can Use Image Generation or Reference Visuals

In the original workflow this time, before making the dashboard, UI concepts or logo drafts were created with GPT Image 2 and saved as project materials.

Preparing reference visuals before implementation makes the look of the dashboard more stable.

This is a very good way to use it.

If you suddenly ask an AI to "make a cool dashboard," it might result in a screen that is safe but leaves a weak impression. On the other hand, if you create reference images or a direction first, the design axis becomes easier to define.

For example, you can specify:

• I want a dark management screen.
• I want to add a bit of YouTube-like color.
• I want to make indicators easy to see with a card type.
• I want graphs to be not too flashy and for practical use.
• I want a screen that content creators want to see every week.

By deciding on such a direction first, the UI Codex makes will also be one step more professional.

Especially for articles or services for Japan, screens that are easy to see, calm, and organized are often more easily accepted than excessively flashy designs.

Turn Work Procedures into Skills

Work that went well once in Codex can be saved as a Skill.

A Skill is, simply put, a "reusable work recipe."

Once created, an analysis flow can be saved as a Skill and called up immediately next time.

For example, this YouTube comment analysis has many steps:

1. Retrieve comments from the YouTube API.
2. Save comments.
3. Categorize them.
4. Extract questions.
5. Generate Excel.
6. Update dashboard JSON.
7. Create graph images and auxiliary files.
8. Verify the screen locally.

It's tedious to explain this every time with a long prompt.

So, you turn it into a Skill.

If you make it a Skill, you can reproduce the same work with a short instruction from the next time.

You can call up saved Skills with slash commands or natural language.

For example, you can ask:

"Run the YouTube comment analysis Skill and update the Excel and dashboard with the latest data."

Or, you can call it as a slash command.

This concept is very important for using Codex in practice.

A common failure in AI utilization is ending with a one-off conversation every time. Looking for the prompt that worked yesterday again today. Explaining once more while remembering the previous procedure. The output changing because you used a slightly different wording.

Work won't be stable this way.

If you leave the procedure as a Skill, you can reproduce good work. Furthermore, if an improvement is found, you just need to update that Skill.

In other words, the more you use Codex, the more it grows into your own dedicated work environment.

Distinguish Between Global and Project Skills

Skills have two main storage locations.

One is Global Skills. These are Skills that can be used in any project.

The other is Project Skills. These are Skills used only within that project.

Which one to choose depends on the application.

For example, general tasks like "summarizing meeting minutes," "analyzing CSV," or "creating article structures" are suitable for Global Skills. On the other hand, things with many project-specific rules like "comment analysis for a specific YouTube channel," "updating sales reports for a specific company," or "FAQ generation for a specific product" are safer as Project Skills.

This YouTube comment analysis contains a lot of project-specific information. This is because the API key, target channel, output destination, dashboard configuration, analysis categories, etc., are fixed.

Therefore, it's natural to save it as a Project Skill first. If you later want to "use it for other YouTube channels," you can generalize it and move it to Global Skills.

Automate Weekly Tasks with Automation

Tasks turned into Skills can be further executed periodically with Automation.

Codex has a feature called Automations, which can execute specified tasks on fixed days or times.

In Automations, you can check currently set periodic execution tasks.

In this example, an automation called "Weekly YouTube Comment Insights Refresh" is set. It's content that updates the YouTube comment analysis every Sunday at 17:00.

You can set the automatic execution prompt, execution frequency, model, execution environment, etc.

You can write quite specific instructions inside an Automation.

For example, content like:

• Execute the YouTube comment analysis workflow.
• Retrieve new comment data.
• Regenerate the Excel report.
• Update the dashboard JSON.
• Verify the screen in the browser.
• If there are no problems, commit to GitHub.
• Leave it to Vercel's automatic deployment.
• If there are no changes, do not make an empty commit.

By setting this up, you can significantly automate weekly analysis work.

For a YouTube creator, viewer comment trends are updated at a fixed time every week. For a corporate marketing manager, a draft of a weekly report is automatically created. For customer support, you can periodically grasp changes in inquiry trends.

However, there are points of caution.

In the case of local execution, the computer must be on and Codex must be in a state where it can operate. If the laptop is closed or Codex is closed, periodic execution will stop.

If you want it to run reliably 24 hours a day, you should consider a configuration that runs in a cloud environment or VPS.

Be Careful with Model Settings in Automation

A point often overlooked when using Automation is the setting of the model used.

The model used in normal chat is not necessarily reflected in automation as is. You need to check the model for each Automation.

In the image example, the model is set to GPT-5.5 and Reasoning is set to High on the Automation detail screen.

In Automation, you need to check the execution model separately from normal chat.

If the model setting is not appropriate, processing might become slow or not as stable as expected.

Especially for tasks where execution time is a concern, like weekly report updates, the model setting is a point you want to check.

Also, if an Excel file is left open, Codex might not be able to overwrite it. This is mundane, but it's a common problem in practice.

When setting up automation, it's good to include notes like this in the Automation prompt:

• If the Excel file is open and cannot be updated, report that.
• If it fails, specify at which step it stopped.
• If data cannot be retrieved, do not overwrite with an empty report.
• If there are no changes, do not force a commit.

By including these rules, the reliability of automation increases.

Publish with GitHub and Vercel

A dashboard made locally can only be seen on your own computer.

If you want to share it with team members or clients, you need to publish it to the web. The combination of GitHub and Vercel is convenient for that.

The basic flow is as follows:

1. Create a dashboard with Codex.
2. Create a repository on GitHub.
3. Send code from Codex to GitHub.
4. Load the GitHub repository in Vercel.
5. Deploy.
6. Thereafter, Vercel automatically updates every time changes are sent to GitHub.

With this configuration, just by working in Codex and reflecting it on GitHub, the public site is also automatically updated.

For small-scale dashboards or web apps for internal verification, it's a very easy-to-use configuration.

Of course, you need to be careful about the scope of publication. While public data like YouTube comments is relatively easy to handle, you must always consider authentication and access restrictions when handling customer information or internal data.

When using it in Japanese companies, the handling of personal information and confidential information should be particularly cautious.

Separate Work with Side Chat

Codex also has a convenient feature called Side Chat.

This is a feature that allows you to open a sub-chat with the same project context, separate from the main work thread.

Using Side Chat, you can ask other questions or perform checks without stopping the main work.

For example, suppose you are proceeding with dashboard implementation in the main chat. In the middle of that, you might want to perform another check like "What are the limits of this API?" or "Should I change the column configuration of this Excel sheet?"

If you mix questions into the main chat every time, the flow of work gets messy.

Using Side Chat, you can ask in a separate thread while maintaining the flow of the main work. Since you can just close it when the check is finished, it's also easier to organize work logs.

This is a small feature, but it's quite effective in long projects.

Change Reply Style with Personality Settings

Codex has Personality settings.

Codex's reply style can be chosen from Friendly and Pragmatic.

Friendly is a warm and cooperative reply style. It's suitable when explanations are polite and you want to proceed while conversing.

Pragmatic is a concise and task-centered reply style. This is suitable if you want to proceed quickly in practice.

In Japanese business use, Friendly might be fine at first, but many people might feel Pragmatic is easier to use once they get used to it.

Especially when using Codex every day, if there are many unnecessary explanations, it can feel a bit heavy. By setting it to Pragmatic, it returns the main points, making it easier to proceed with work.

Full Access is Convenient but Use with Caution

Codex also has Full Access settings.

Enabling Full Access makes work faster, but since permissions expand, it needs to be used cautiously.

When Full Access is enabled, Codex can perform file editing and command execution with wider permissions. Since the effort of approval decreases, work becomes faster.

However, there are risks accordingly.

• Possibility of editing unintended files.
• Possibility of accessing the outside via the network.
• Possibility of touching files containing secret information.
• Possibility of executing incorrect commands.

Of course, Codex is designed to move cautiously, but since permissions are expanded, the human side also needs to be careful.

I recommend using it with normal permissions at first. After getting used to the project configuration and being able to trust Codex's behavior, use Full Access as needed.

Especially when handling work PCs or company data, it's safer not to turn on Full Access easily.

Be Conscious of the Context Window

Codex has a Context Window to maintain the context of conversations and work.

Codex displays context usage and automatically compresses it as needed.

When doing long work, conversation history and file content increase. Codex automatically compresses the context, but it's more stable to leave important project information in files as much as possible.

In that sense, agents.md and Skills are important.

If you leave information only in the chat, the context might thin out in the middle of long work. On the other hand, if you leave rules and procedures as project files, Codex can refer to them.

The more a project is used long-term, the more important the consciousness of "leaving it in a file" rather than "explaining in chat" becomes.

Starting from Small Tasks is Realistic

Reading this far, you might be at a loss as to where to start because there are too many things Codex can do.

I recommend starting from small routine tasks.

For example, tasks like:

• Analyzing YouTube comments once a week.
• Creating X post drafts from past reactions.
• Categorizing inquiry emails.
• Creating proposal drafts from sales notes.
• Reading CSV and creating simple reports.
• Updating internal FAQs.
• Organizing Notion notes.
• Making weekly reports in Excel.

You don't need to make a large business system from the start.

Rather, it's good to first choose "tasks that are tedious to do every week but can be rule-based."

What Codex is suitable for is not just completely creative work. Rather, it has strengths in work that has repetition, where input and output are fixed to some extent, and where a bit of judgment is needed every time.

YouTube comment analysis is typical of that.

• There is input called comments.
• There are processes called categorization, aggregation, and summarization.
• There are outputs called Excel and dashboards.
• Judgment materials like the next video idea or reply candidates are obtained.

Such work has a very good affinity with Codex.

Examples of Utilization for Japanese Sole Proprietors and Small Teams

If you use Codex in Japan, it is particularly suitable for sole proprietors, small teams, marketing managers, and content creators.

For example, a YouTube creator can create plans for the next video from comment analysis. Someone writing on note or a blog can organize article ideas from reader reactions or search keywords. An online instructor can categorize student questions to improve teaching materials. A SaaS company can analyze inquiry or chat logs to improve help pages. A sales representative can create proposal content or follow-up text from negotiation notes. A recruitment manager can organize questions from applicants or interview notes.

Even without making a large system like a big company, Codex is sufficiently useful.

Rather, the effect might be more apparent in small teams. This is because just by automating routine tasks, you can return time to the judgment and planning that humans should originally do.

Tips for Mastering Codex

Finally, I will organize the tips for mastering Codex in practice.

First, think of work in folder units. Divide folders for each project and organize necessary files.

Next, create agents.md. Share the project purpose and rules with Codex.

And, don't let it work suddenly; make a plan in Plan Mode. For larger tasks, it's harder to fail if you check the flow first.

Turn successful procedures into Skills. Instead of giving the same explanation every time, save them as reusable recipes.

Turn tasks done periodically into Automations. However, note that for local execution, the PC needs to be on.

Once a web screen is made, check it with Browser Use. Look at the actual screen, not just the code, and check usability.

Save API keys and secret information in .env.local. Be careful not to accidentally publish them to GitHub.

Use Full Access cautiously. It's convenient, but since permissions expand, the normal setting is recommended at first.

Just by pressing these points, Codex becomes considerably easier to use in practice.

Summary

Codex is not a tool that perfectly completes everything in one shot like magic.

It might fail in the first execution. It might get stuck in API connection. It might not be able to update because the Excel file is left open. The dashboard UI might turn out more ordinary than expected. Automation execution might be slow.

However, all of those can be improved.

The important thing is not to leave failures as one-offs.

Turn successful procedures into Skills. Leave the cause of failure in agents.md or project notes. Turn weekly tasks into Automations. Incorporate screen verification into Browser Use. Accumulate work knowledge within the project folder.

By creating this flow, Codex becomes not just a chat AI, but your own dedicated practical partner.

In this YouTube comment analysis example, we were able to do the following using Codex:

• Retrieve YouTube comments.
• Analyze more than 200 comments.
• Create an Excel report.
• Extract frequently asked questions.
• Organize reply candidates.
• Come up with the next content ideas.
• Create a web dashboard.
• Verify in the browser.
• Make it reusable as a Skill.
• Set up weekly automatic updates.

These are connected within one project folder.

If you use Codex in a Japanese workplace, it's just right to think of it as "systematizing the work you do every week together with Codex" rather than "leaving everything to AI."

It can be a small task at first.

• The Excel you make every week.
• The comments you read every time.
• The reply text you write similarly many times.
• The report you summarize monthly.
• The FAQs scattered within the company.
• The SNS reactions you look back on after posting.

Choose one such task, have Codex organize the procedure, execute it, turn it into a Skill, and automate it if necessary.

Just by acquiring this pattern, the value of Codex will jump up.

What's important in the AI era is not just knowing convenient tools. It's finding the flow of work that AI can enter into within your own work.

Codex is a quite powerful option for creating that flow.

Codex free workshops are scheduled to be held at any time!

**

Please "Like," "Quote," and "Follow"!**