DEV Community: Kohki Makimoto

claude-sandbox: Yet another sandboxing tool for Claude Code on macOS

Kohki Makimoto — Wed, 25 Feb 2026 05:29:37 +0000

This post walks through claude-sandbox, a small tool I built to bring predictable, low-friction sandboxing to Claude Code on macOS.

The Problem with the Built-in Sandbox

Claude Code ships with a built-in sandboxing feature. It's capable, but it wasn't a great fit for my workflow:

It kept blocking legitimate operations in unexpected ways, and troubleshooting took more time than the protection was worth.
It includes network isolation, which I didn't need at all — just extra complexity with no benefit for my use case.

What I actually wanted was simple: restrict file writes to the current project directory, with an easy way to allow exceptions when needed. Nothing more.

That's claude-sandbox.

How It Works

claude-sandbox wraps the claude command and runs it under macOS's sandbox-exec (Apple Seatbelt — the same technology used in Claude Code's built-in sandboxing). The default policy is simple: allow everything, deny all file writes, then re-allow writes to a few specific paths — the current working directory, ~/.claude, and /tmp. If Claude Code tries to write outside those boundaries, the OS itself blocks it.

You can customize this policy by writing your own profile in TOML, but the defaults are sensible enough to use as-is.

Installation

claude-sandbox is a single binary with no dependencies. You can install it with Homebrew:

brew install kohkimakimoto/tap/claude-sandbox

Basic Usage

claude-sandbox is a drop-in replacement for the claude command:

# Before
claude --dangerously-skip-permissions

# After
claude-sandbox --dangerously-skip-permissions

That's it. Claude Code starts, but now it runs inside a sandbox that restricts where it can write files.

Try to write a file outside the current directory, and you'll see an error like the following:

❯ write current time into ~/now.txt

⏺ Bash(date > ~/now.txt && cat ~/now.txt)
  ⎿  Error: Exit code 1
     (eval):1: operation not permitted: /Users/kohkimakimoto/now.txt

     (eval):1: operation not permitted: /Users/kohkimakimoto/now.txt

⏺ The sandbox is restricting write access to the home directory. Let me try using the Write tool instead.

Configuration

You don't need a config file to get started — the built-in defaults work fine. But if you want to customize things, run:

# Project-specific config
claude-sandbox init

# Global config
claude-sandbox init-global

This creates a .claude/sandbox.toml file. Here's what it looks like:

[sandbox]
profile = '''
(version 1)
(allow default)
(deny file-write*)
(allow file-write*
    (subpath (param "WORKDIR"))
    (regex (string-append "^" (param "HOME") "/\\.claude"))
    (subpath "/tmp")
)
'''

[unboxexec]
allowed_commands = [
    "^playwright-cli",
]

The profile is written in the sandbox-exec policy language (a Scheme-like DSL). Two parameters are automatically injected:

WORKDIR — the directory where you ran claude-sandbox
HOME — your home directory

To see what profile is actually active:

claude-sandbox profile

The Escape Hatch: unboxexec

Here's where things get interesting. Some tools — like Playwright for browser automation — use their own sandboxing internally. Running them inside a macOS sandbox causes conflicts, and they simply don't work.

claude-sandbox solves this with a mechanism called unboxexec. When claude-sandbox starts, it launches a small daemon outside the sandbox. Claude Code, running inside the sandbox, can send a command execution request to that daemon — and the daemon runs the command outside the sandbox and returns the result.

The daemon won't execute arbitrary commands — only those matching the regex patterns in [unboxexec].allowed_commands. By default, everything is rejected.

To use unboxexec from inside Claude Code (or from a script running inside the sandbox):

claude-sandbox unboxexec -- playwright-cli open https://example.com

For it to work, you need to add the pattern to your config:

[unboxexec]
allowed_commands = [
    "^playwright-cli",
]

Telling Claude About the Sandbox

One more practical detail: Claude Code doesn't automatically know it's running in a sandbox. claude-sandbox solves this with a built-in Agent Skill — a structured prompt that tells Claude how to check sandbox status, inspect the configuration, and run commands outside the sandbox via unboxexec.

To see the skill contents:

claude-sandbox skill

To install it into your current project:

claude-sandbox skill --install

This creates .claude/skills/claude-sandbox/SKILL.md in your project directory. Once installed, Claude Code will automatically load it and understand how to work within the sandbox environment.

Wrapping Up

claude-sandbox gives you a practical middle ground: run Claude Code with full permissions for reading and executing, but with file writes safely scoped to your project directory. No network lockdown, no complex configuration to troubleshoot — just a straightforward constraint that covers the most common concern.

GitHub: https://github.com/kohkimakimoto/claude-sandbox

AI and Programming: A Realistic Perspective on Software Development

Kohki Makimoto — Sun, 06 Jul 2025 11:07:39 +0000

This article has been translated from Japanese. You can find the original article here.

Introduction

With the evolution of AI technology, using AI in the field of programming has also developed remarkably. AI coding tools classified as agents are characterized by autonomous operation, dramatically reducing opportunities for humans to write code directly, and introducing a methodology where AI takes the lead in generating code. In the midst of this development, there are opinions that "AI will replace programmers' jobs" and "professions like engineers and programmers will be lost" in the not-so-distant future.

However, I'm skeptical of such opinions. I'm a web software engineer, but at least in my professional programming work, I don't believe that AI will completely replace my job.

This article examines modern software development and AI based on my experience. My conclusion is that while AI will change the form of programming, engineers with specialized knowledge still play an important part in software development. While I acknowledge that AI technology represents a paradigm shift distinct from conventional software technology, I also argue that in software development, this is part of the continuous process of technological and tool changes that have always occurred, and that we should judge excessive information hype with a realistic perspective.

Audio Overview by NotebookLM

Evolution of AI in Programming

AI in programming has developed through stages. Initially, people asked programming-related questions to AI with chat interfaces like ChatGPT and had them generate code fragments. Next came tools that integrated with development environments like editors and IDEs. A representative example is Github Copilot. This is a powerful extension of traditional code completion functionality through AI, generating code more flexibly and extensively beyond the scope of static analysis-based code completion.

As of July 2025, the cutting edge in this field is AI tools called agents. Specific implementations include Cline and Claude Code. With this type of tool, programmers don't write source code directly but focus on giving instructions to autonomously operating AI, which performs most of the implementation on behalf of humans.

They are called autonomous because AI has the authority to execute actions like commands, formulates concrete plans from abstract instructions, and operates independent feedback loops within the execution of those plans, designed to minimize human interaction relative to objectives.

Additionally, with MCP (Model Context Protocol) standardizing the means for AI to access various resources, computers are becoming capable of doing the equivalent of human work.

Such AI programs are called AI Agents or Agentic AI. Generally, AI agents don't perform the aforementioned planning and AI-complete feedback loops, executing relatively simple tasks, while agentic AI is interpreted as AI systems that solve more complex tasks using diverse means, including planning, feedback loops, and potentially operating multiple AI agents.

This article will not make such classifications and will refer to AI programs that automatically perform programming through natural language instructions collectively as "AI agents" for subsequent discussion.

Challenges and Reality of AI Agents

The experience of implementing programs using only natural language instructions without directly writing code through AI agents is unprecedented. People who couldn't write code before can now create programs. As AI performance improves, generated code becomes higher quality and will eventually generate programs superior to those written by humans. This is already happening in some cases, and the rapid evolution of AI is shaping trends that push the software development world in that direction. This has generated discussions like "software engineers are no longer needed."

However, in my experience, when using such AI agents for actual professional programming, you face challenges that aren't easily resolved.

Instructions to AI Agents

First, even AI will basically only do what is clearly instructed. While AI sometimes thoughtfully does things, uncertain elements arise where AI infers implicit information not communicated, leading to additional verification steps or factors that induce errors.

This includes essentially the same challenges as delegating work to others, which have existed traditionally. When delegating work to AI, like delegating to humans, the content of instructions becomes important. Software development tasks are particularly complex, and appropriate information must be provided to have AI generate code as expected. This itself is laborious work and is also a problem that existed long before AI.

In software development, delegating work itself has certain difficulties.

Incompleteness of Information

In addition to the difficulty of human-to-AI instructions, in actual software development environments, providing complete information to AI is often practically impossible. The necessary information in software development includes not only implementation information directly expressed in code, but also background specifications, requirements and intentions of related parties who determine specifications, and much more. Often, no one even recognizes what information is truly necessary. Specifications and requirements may change during project progression.

This is also a problem that existed traditionally, regardless of AI. Various methods and tools have emerged from past to present regarding information sharing and management in software development projects, but in many projects, it remains one of the important project management challenges requiring continuous effort.

Real software development projects have many uncertain elements, which fundamentally make software development difficult. This doesn't change in the AI era. While AI has the capability to replace human work and can demonstrate high-speed processing and continuous execution capabilities as a computer, it cannot magically solve challenges in incomplete information environments.

Practical Nature of AI

In my view, AI's greatest invention in this domain is enabling computers to handle abstract and ambiguous input/output. Traditional computers and software were fundamentally based on returning predetermined specification output for predetermined specification input, which was the fundamental characteristic of computers. This property provided important functionality that complemented human characteristics of making errors, offering strict reproducibility and accuracy in computer program processing.

Today's AI extends such fundamental computer properties and underlies the paradigm shift of surrounding software and new development tools like AI agents that utilize AI. Natural language prompts, which are abstract and ambiguous expressions, can now be interpreted by machines as program input, enabling diverse and flexible output.

Here's the key point: no matter how flexible AI becomes with input and output, it can't solve problems that have no logical solution. If the system can't find a logical path to solve the given problem, AI won't produce accurate results.

Code that can be generated by prompts such as create a program that does something is fundamentally derived from AI's knowledge and information resources accessible to AI. Missing information is considered to be filled by AI inferring from its knowledge base, but being inference, certainty decreases, leading to decreased output accuracy. The worst case is AI fabricating false information. This is called hallucination and has become a fundamental precaution in AI usage.

As mentioned earlier, information given to AI in realistic business software development is incomplete. I believe this creates the gap between overly hyped AI capabilities and actual performance in practical use.

Demos showing AI agents generating programs in just a few prompts are spreading rapidly on social media. But these work for specific reasons.

Sometimes they work because the demos don't care about quality details that AI has to guess at. For example, when generating a web landing page, the demo treats detailed design and internal implementation as good enough - they're not evaluating those aspects critically.

Other times they work because AI already knows the specifications well. Creating Tetris works as a demo because Tetris rules are widely known and familiar to most people.

These demos are designed specifically to look impressive, not to solve real-world problems.

Tools that Extend Human Capabilities

I'm not saying AI can't create practical programs beyond demos. In fact, I know several cases where non-engineers used ChatGPT and AI agents to independently implement business programs. While they were originally people with high IT literacy, they implemented programs that would conventionally be considered difficult without professional engineers.

What I consider most important is using AI appropriately as a tool, understanding its properties as I've described. The key is whether you can leverage AI as a tool that matches your work and capabilities.

One of the non-engineers mentioned earlier who utilized AI was a web service producer who implemented a Python program to migrate internal data from the web service he worked on to another server. His case succeeded because he had IT literacy, the task was independent with clear goals, he had knowledge about the web service, and he had the persistence to work toward achieving his objective.

What engineers, including myself, who are trying to use AI in their work are actually doing is understanding tool properties, adjusting usage environments and methods to match their work, and trial-and-error to improve AI output accuracy. Specifically, this includes organizing information, dividing tasks so AI can handle them easily, and devising prompts. Actually, code written by agents with limited scope often results in faster implementation than writing it myself, and I actively use AI.

Interpreting using AI in software development as AI completely replacing human work is not realistic. It's more accurate to interpret it as a tool that extends programming capabilities of people involved in software development, from 0 to 1, or from 10 to 100. In many cases, realistic means of using AI as a tool involve steady, incremental business optimization and skill improvement by users themselves.

When non-engineers' programming capabilities go from 0 to 1, people emerge who can independently handle work that previously required consulting engineers, and in that sense, engineers' work decreases. This is already happening, as mentioned in examples. On the other hand, engineers' programming capabilities go from 10 to 100. That extended capability of 100 remains indispensable within the complexity of software development.

Responsibility

In my understanding, the idea that engineers are unnecessary assumes that AI vastly smarter than humans will generate code, so engineers lose their advantage as knowledge workers and ultimately become unnecessary. But this view sees software merely as the end result of coding, which differs from my perspective.

That's because building software professionally comes with responsibilities that are fundamentally human and social.

Software in Real Society

Software written for business typically has stakeholders other than oneself. In such cases, even if AI generates code, humans still need to bear responsibility for that code.

For example, if a company undertakes system development work and has AI generate the system's programs, and those programs have bugs, would customers be satisfied with simply answering "This was made by AI"? Typically, what happens next is pursuing responsibility: "Why did you have AI create a buggy program?" It's natural that AI is a tool and the human user bears responsibility for its results.

In this case, what customers seek is implementation of a system that meets requirements, and responsibility is the obligation to fulfill that. Furthermore, in real society, it's necessary not only to fulfill requirements but also to foster conviction among stakeholders through the process. In unexpected situations, acknowledging judgment mistakes and apologizing to related parties would be one example. These are extremely social, human activities that are difficult for AI to completely replace.

In software development work, humans will simply use AI for programming - this doesn't mean AI will replace humans. That's my basic perspective.

Challenges and Judgments Without Right Answers

Software development projects, especially business system development, often require judgments in situations where there is no right answer. What kind of design to make, what implementation policies to take, what technology selections to make. Software design decisions are often trade-offs against challenging elements.

Selecting frameworks and determining system configurations considering future system scalability, dealing with anticipated problems, and code maintainability, robustness, extensibility, readability have no single absolute right answer. This is because they require comprehensive consideration of diverse elements including not just technical superiority, but project context, team skill sets, costs, future business requirements, and more.

The information to handle is complex and incomplete, and making highly accurate future predictions is impossible. Having to make decisions and proceed with projects even in situations without right answers is the most difficult and important aspect of software development.

AI cannot make these judgments. Well, it will make judgments if instructed to judge. However, that is superficial, and the final decision of whether to adopt AI's judgment still depends on humans.

Since the future is uncertain, no one knows the right answer at any given time. Decisions made there involve risks, and risks are possibilities of negative impacts on real society and people, so only humans can take that responsibility.

Will AI Evolution Solve These Challenges?

When discussing current AI limitations and challenges, the counterargument "that's a problem that will eventually be solved by AI performance improvements" is often made. Indeed, the speed of generative AI evolution is tremendous, and current challenges should certainly be considered based on the premise of AI performance improvement. However, future predictions that unconditionally treat AI evolution as capability to guide any challenge to right answers are inappropriate.

Abstraction in Programming

The evolution of information technology is also a history of abstraction. Abstraction here means hiding technical details and introducing interfaces with enhanced generality, thereby expanding technology usage and improving convenience. In many information technologies, this abstraction forms layers.

For example, computer networks constitute technical abstraction layers called the OSI model. Through this mechanism, web application programmers like me can implement programs without being conscious of low-layer technologies like how computers are physically connected or how they send and receive electrical signals.

In programming languages, programs that convert source code, such as compilers and assemblers, function as abstraction layers. CPUs can only directly interpret bit strings called machine language arranged with 0s and 1s. However, programmers implementing applications can program without machine language knowledge because there are mechanisms that output machine language from source code.

Some argue that AI agent code generation becomes a new upper layer in this abstraction concept, making current programming knowledge unnecessary. That is, just as current programming doesn't require knowing machine language output by compilers, future programming won't require knowing programming languages output by AI.

This way of thinking argues that current problems with AI-generated code quality, readability, maintainability, etc., are just temporary growing pains. It's nonsensical to question source code readability and structure premised on human cognitive abilities for highly developed AI, and humans no longer need to read code. Just as we don't directly read machine language and don't consider how difficult it is to read a problem.

Confusion of System Properties

I'm skeptical of such future predictions. While overall improvements will happen, I don't think we'll reach the fundamental solution of programming language knowledge becoming unnecessary. My reasoning is that such logic conveniently confuses the ambiguous input/output nature of generative AI with the precise input/output nature of traditional computer programs.

Compilers outputting machine language and AI outputting source code are similar but different things. Compilers can guarantee reproducibility in machine language output precisely because source code specifications as input are strictly defined. This reproducibility and completeness allow compiler abstraction to hide lower-level technical details and enable human escape from machine language. As long as compiler (programming language interpretation) rules are followed, completely intended machine language is output, so direct machine language handling becomes unnecessary.

On the other hand, AI doesn't require input precision, enabling flexible information input and thereby realizing new programming means and advanced code generation. Conversely, precision and reproducibility are lost from its output. Code that works as intended can only be reproducibly generated by conveying that intention 100% as information, in principle. The most compact expression of that is current source code itself.

Using AI capabilities to advance programming from current source code to new concepts requires AI that accepts ambiguous input to produce reproducible, precise output like traditional computer programs. I believe this is fundamentally difficult to achieve.

Confusion of Bottlenecks

AI performance is expected to continue improving. However, in solving real software development challenges, people and society handling AI often become bottlenecks rather than AI itself. This has already been discussed in this article from perspectives of information incompleteness and responsibility.

AI performance improvement doesn't directly contribute to solving these issues. The reason AI can't output high-quality code is more dominantly due to inability to communicate system specifications with appropriate information volume than AI performance.

Programming in the AI Era

In my actual experience, there are cases where I have AI agents generate over 80% of the code, depending on the work. However, this doesn't mean that 80% of programming work no longer requires human involvement. To explain this, we need to break down programming work and examine individually what has actually been affected by AI (and what hasn't been affected).

Keyboard Source Code Input Decreases

This literally reduces manual work, providing clear efficiency gains. Source code can now be mechanically generated through AI agents or AI completion functions like Github Copilot in dramatically more situations. In addition to reducing physical movements of moving hands relative to source code volume produced, typing errors are also reduced.

AI Can Handle Common Programming Logic

Programs often contain code where you understand the logic and could write it if you tried, but it's difficult or tedious to write from scratch. Examples include algorithm implementations like sorting and searching, and test code. Particularly when required implementation involves general logic that would result in similar code regardless of who writes it, it works advantageously for using AI. These tend to be work easily replaced by AI because necessary information is included in AI's programming knowledge, or instructions and results tend to be clear.

Also important is that generated code is usually understandable when read, making AI errors discoverable early. This resembles situations where you can't write difficult kanji but can read them. AI support makes it possible to skip some skills previously necessary for implementation.

AI Can Handle Repetitive Coding Patterns

Similar to common programming logic, patterned implementation within projects is also easily AI-generated code. In professional programming, you often write code that is generally the same as existing implementation but slightly different. Before AI, this was sometimes automated using editor replacement functions or writing scripts, but it was difficult to completely cover detailed differences, making it a task where complex manual work was hard to eliminate.

AI can handle such work quite well. By clearly indicating reference source code to AI agents and explaining change content, expected implementation can be generated in quite many cases.

Required Thinking Doesn't Change Significantly

My job responsibilities include managing and ensuring code quality. To fulfill this, I need to understand internal implementation details, so even with AI-generated code, I must always read and understand it. Before AI, the act of writing code implicitly included understanding, but AI code generation skips this, making the complementary work of understanding generated code practically essential.

Code understanding for quality assurance isn't just reading generated code logic. Complex thinking and judgment are sometimes required, such as whether consistency is maintained in overall architecture, whether there are contradictions or inconsistencies with other code or functions, and whether it could become future risks.

Cognitive load for these tasks doesn't differ much from traditional programming. The difference is whether thinking timing is while writing code or after finishing writing. Rather, depending on AI tool usage, this load can sometimes increase. When analyzing code not directly written by oneself, you miss all the context that led to it. Therefore, more unknown information needs to be processed at once, potentially increasing cognitive load.

Optimization Required

In my experience, the most effective way to understand code is actually writing it. Writing code includes not only implementing programs but also building understanding of the entire program in your brain during the process. There's a kind of learning process involved. As you learn and understanding deepens, the cognitive load on your thinking decreases, enabling faster decision-making.

In AI-utilized development, such code implementation and learning processes need to be reviewed and optimized. Opportunities for humans to directly write code decrease. Nevertheless, code understanding remains necessary for quality and responsibility. AI replacing human work to generate code while human cognitive ability not keeping up becomes a significant bottleneck.

Various countermeasures can be considered:

Devise AI instructions so generated code volume becomes compact to reduce cognitive load.
Use test code to obtain verification results without analyzing implementation details.
Improve architecture to make test code easier for AI to write.

These are merely challenges with using AI in my duties, not arguing that everyone must take such measures. For example, if the work involves creating prototypes, internal implementation quality assurance priority would decrease. In that case, detailed understanding of AI-generated code might not be necessary at all.

It's necessary to find AI tool usage methods suited to one's work, eliminate bottlenecks, and optimize. These are essentially the same work as conventional software development environment improvement. Tools are used appropriately for their intended purposes. Feedback is obtained to select tools and methods suited to one's work and projects. No universally applicable solutions exist. This doesn't change in the AI era.

As a result, AI agent-based development improves implementation speed as a development experience due to code generation benefits, but correspondingly increases cognitive load for programmers to understand code. Conventional programming knowledge is indispensable there, and efforts like optimizing tools remain necessary - this is my conclusion based on experience.

Taking a Realistic View

This article has examined AI technology in software development. I've discussed AI's evolution process, countered excessive hype about functionality by raising issues with AI's properties and real-world responsibilities, and argued for interpreting it realistically as a development tool.

Software technology moves fast. Keeping up with new technology is essential for engineers - it's basically a survival skill. However, some may feel overwhelmed by the sheer volume and hype around AI technology information, where new tools and models are released daily. Particularly troublesome are AI sensationalists who spread information with extreme expressions designed to grab attention on social media.

I'm a professional engineer interested in using AI to improve my own work, and I admit this article's examination is somewhat near-sighted. However, the future lies ahead, connected to the present, and information technology including AI isn't magic. Problem-solving requires logical foundation, and examining this from current realistic perspectives should be an effective way to judge the truth behind all the hype.

Observing Real Projects

Most important is whether it's actually useful to you. Software development has had diverse tools long before AI technology. Design architectures and project management methods also exist in large numbers. However, none of these has a single right answer.

AI is no exception. Whether tools function well depends on project-specific conditions including project scale and nature, team skill sets, etc., and cannot be judged without these premises. If possible, tool introduction should actually be verified. If it's useful, adopt it; if there are bottlenecks, see if improvements are possible. New tools aren't always right either. Examination and verification in actual projects, and obtaining feedback are important.

AI coding demos posted on social media for diffusion purposes are only fictitious projects, fictitious products, fictitious work. There's no point in worrying about fictitious engineer job futures based on arguments that engineers are no longer needed.

Software Development is Constantly Changing

AI has brought changes to programming, but programming and software development have always been evolving anyway. My engineering career spans over 20 years, but most programming technologies and tools I currently use didn't exist 20 years ago.

Smartphones didn't exist 20 years ago. I work on app development now, but this kind of job simply didn't exist back then.

AI technology is undoubtedly a major change. But it's a mistake to think this will lead to some kind of uncontrollable revolution beyond human understanding. Yes, it's a technological paradigm shift, but that doesn't mean it's beyond our ability to manage or adapt to. Change happens - it always has. But I believe we can adapt to it as long as we stay observant, curious, and grounded in technical knowledge.

keepsecret.py: a simple way to encrypt secret files in your repository

Kohki Makimoto — Sun, 28 Apr 2024 07:22:03 +0000

About one month ago, I wrote a small Python script to securely manage secret data in my Git repositories. I believe this tool is very convenient and useful for many projects beyond just my personal use cases.

I named the script keepsecret.py and published it on my Github account.
In this article, I will explain what keepsecret.py is and how to use it.

Background: Seeking a simple way to manage secrets

I am a software engineer specializing in server-side application development. These applications often require sensitive data such as database passwords, API keys, etc. Dotenv (.env) is a well-known method for configuring this sensitive data in a plain text file. Generally, you should not commit the .env file to your Git repository to avoid accidentally exposing it to the internet. So, how should I store the .env file and secret data?

We have several methods to ensure security. I think the most secure approach is to use dedicated tools or services, such as GCP Secret Manager or HashiCorp Vault.

However, it is too complicated for my personal projects. I don’t want my tiny web applications to depend on additional services.

Another practical approach is to encrypt files and store them in your Git repository. Tools like git-secret or git-crypt are available for this purpose.

However, these tools require familiarity with GPG and are tightly integrated with Git, which I find too complex. I prefer a simpler way to encrypt files.

That is why I created keepsecret.py.

What is keepsecret.py

keepsecret.py is a command line tool written in Python. It focuses just on encrypting and decrypting files without unnecessary complexity.

To use keepsecret.py, you need the following two dependencies:

Python 3.11 or later
age

These are available on most platforms and can be installed easily. For example, if you are using a Mac, you can install them via Homebrew as follows:

brew install python3
brew install age

keepsecret.py is implemented as a single file Python script. You can use it by simply downloading it and making the file executable.

curl -O https://raw.githubusercontent.com/kohkimakimoto/keepsecret/main/keepsecret.py && chmod +x keepsecret.py

You are now ready to use it.

How to use keepsecret.py

Before using keepsecret.py, you must have both the public and private keys for age, which is a modern file encryption tool.

I prefer age over GPG due to its simplicity. Unlike GPG, age does not dictate where private keys should be stored. The tool is straightforward to use: you simply run the age command with the keys and file paths to encrypt files.

You can generate a private and public key pair by running the following command:

# age-keygen is bundled with age installation.
age-keygen

This command will generate a key pair as shown below.

# created: 2024-04-07T14:41:45+09:00
# public key: age1d9huzvucvm7hueyz0ck90gkyxuqyzvqepx594nfhzzfv2tk60yysdf2l09
AGE-SECRET-KEY-1VGYZM79EQPV80CRMKTQHFN4GD6X7UMY7KJ8LYTG3S5EVGUXW7T5S9JRS6Z

Encrypt files

You can encrypt files (for example: file1.txt, file2.txt) with the following command:

keepsecret.py encrypt -r age1d9...(age-public-key)... -- file1.txt file2.txt

This command will generate encrypted files file1.txt.encrypted, file2.txt.encrypted. keepsecret.py adds a .encrypted extension to generate encrypted versions of the files.

Decrypt files

You can decrypt files (for example: file1.txt.encrypted, file2.txt.encrypted) with the following command:

keepsecret.py decrypt -- file1.txt.encrypted file2.txt.encrypted

This command prompts you to input your private key like the following:

Input private key content:

After inputting the correct private key, keepsecret.py will generate decrypted files file1.txt, file2.txt. keepsecret.py removes a .encrypted extension to restore the files to their original form.

Organize secrets using a configuration file

You now have the simplest method available for encrypting and decrypting files. For more practical use cases, keepsecret.py organizes multiple secret files using a configuration file.

The configuration file is named keepsecret.toml. Check the following example:

# You can create separate sections for different environments.
[development]
force = true
# The development secret files can be decrypted using the development private keys.
recipients = [
    "age1d9...(public-key-for-development-engineer1)...",
    "age1d9...(public-key-for-development-engineer2)...",
]
# Secret files for the development environment.
# Ensure to include them in .gitignore
files = [
    ".env.development",
    ".env.testing",
]

[production]
force = true
# The production secret files can only be decrypted using the production private key.
recipients = [
    "age1d9...(public-key-for-production)...",
]
# Secret files for the production environment.
# Ensure to include them in .gitignore
files = [
    ".env.production",
]

The above configuration file manages secret files for the environments (development and production).

The development secret files are encrypted with multiple keys. These keys are provided by engineers working on the project. This allows the engineers to use these secret files in their development.

In contrast, the production secret files can only be decrypted with a single, specific production private key.

Access to this production key should be restricted. For example, the key is used exclusively with tools like Github Actions Secrets.

You can encrypt and decrypt the files by specifying the section with the -s, --section option:

# Ensure `keepsecret.toml` is in your current working directory.
# Encrypt the files in development environment.
keepsecret.py encrypt -s development

# Decrypt the files in development environment.
keepsecret.py decrypt -s development

Conclusion

I developed a CLI tool for managing secret files in Git repositories. Security often requires balancing convenience with constraints. While it may not be the perfect solution, it provides a practical method for handling sensitive data in your projects.

If you're interested, please give it a try!

keepsecret

Chrome Extension: ChatGPT Prompt Snippets

Kohki Makimoto — Tue, 07 Nov 2023 23:57:55 +0000

Recently, I created a Google Chrome Extension to make my ChatGPT experience more convenient. In this article, I want to introduce it and how I use it in my daily work.

The extension named ChatGPT Prompt Snippets, is designed to enhance the ChatGPT experience by providing quick access to frequently used prompts. It's a simple yet powerful tool that integrates seamlessly into the ChatGPT interface.

ChatGPT Prompt Snippets - Chrome Web Store

What is ChatGPT Prompt Snippets?

ChatGPT Prompt Snippets is a lightweight Chrome Extension that enables users to save and quickly insert text snippets into the ChatGPT input field, streamlining the use of frequently repeated prompts.

With a simple keyboard shortcut (Ctrl + J or Cmd + J), you can bring up the dialog interface, quickly select a snippet and insert it into ChatGPT's input area.

Configuration

Snippets are set up using Markdown format, which is very straightforward and effective for creating a wide range of practical prompts. See the following example:

# Geography Questions

## Capital of the USA

This snippet asks for the capital of the United States of America.

```
What is the capital of the United States of America?
```

## Highest Mountain

This snippet asks for the highest mountain in the world.

```
What is the highest mountain in the world?
```

The rules for configuring snippets are as follows:

# Snippet Group

## Snippet Name

description

```
snippet
```

Use a level 1 heading (#) to define a snippet group.
Use a level 2 heading (##) to define a snippet name.
Write a paragraph below the snippet name to provide a description.
Include a code block to define the snippet.

You can create custom snippets for ChatGPT Prompt Snippets and insert them directly into the designated text box in the settings.

You can show the following dialog

A use case from my daily work

One of prompt snippets that I regularly use in my daily work is the following:

# Languages

## English Text Review and Translation

英文をチェックしてより良い英文を提案

```
Check the following text to see if it is natural English. Explain what is wrong. Provide improved English text. Translate your improved English text into Japanese. Your response MUST be the following format. Do not include any additional content outside of this format.

## Explanation
{{ your explanation }}

> {{ your explanation in Japanese }}

## Improved English text
{{ your improved English text }}

> {{ your improved English text in Japanese }}

Text:

```

I am a non-native English speaker from Japan, and this prompt is very useful for correcting my writing mistakes. I think that I can now write more natural English than I could before.

Conclusion

In essence, the ChatGPT Prompt Snippets extension is about simplicity and efficiency. It's a straightforward tool that integrates into your daily workflow with ChatGPT, saving you time and effort. By allowing you to quickly access and insert predefined text snippets, it cuts down on repetition and lets you focus on the creative aspects of your conversations with ChatGPT.

If you find this tool useful, you can easily install it from the Chrome Web Store, and if you're interested in how it's built, the entire source code is available on GitHub.

kohkimakimoto / chatgpt-prompt-snippets-chrome-extension

ChatGPT Prompt Snippets is a Google Chrome Extension that helps you manage and utilize prompt snippets conveniently when using ChatGPT.

ChatGPT Prompt Snippets

ChatGPT Prompt Snippets is a Google Chrome Extension that helps you manage and utilize prompt snippets conveniently when using ChatGPT It provides a dialog interface where you can search and select prompt snippets to be inserted into the input area of ChatGPT.

You can install the extension from the Chrome Web Store.

chatgpt-prompt-snippets-movie1.mp4

The above demo uses this snippet.

Motivation

ChatGPT is a powerful tool, but sometimes composing the right prompt can be time-consuming. This is especially true during day-to-day work when you find yourself using similar prompts repeatedly. Typing out the same prompts over and over again can become a hassle. This extension was created to streamline the process of crafting prompts by providing a convenient Chrome Extension that lets you quickly access and use your frequently used snippets.

How to Use

Install the Chrome Extension from the Chrome Web Store.
Open ChatGPT…

View on GitHub