A small vibecoding experiment

I wanted to try building a simple macOS app with AI help. I used Xcode with coding agent. This time I tested Codex.

My starting prompt was:

I want to create a simple macOS app with a retro-vibe pixel mascot that moves along the Dock and runs away when I approach it with the mouse. Create a plan how to implement it in a robust, deployable app.

After Codex created the plan, I continued with:

Build it and provide instructions how to run and test the app.

The idea was simple: a tiny animated mascot living near the Dock, reacting to the mouse, and giving a playful retro feeling.

Press cmd+R and the project is built and running!

Iterating on the mascot

The first version worked, but I did not like the black mascot it created.

So I kept iterating:

• first the default mascot
• then a capybara
• and finally a ghost

The ghost looked the best.

That was probably the most fun part of the process: not only getting code, but also shaping the personality of the app through small prompt changes.

Why I liked this

This felt like a good example of vibecoding.

I did not start with architecture diagrams or a long specification. I started with a fun idea, asked for a plan, then asked the agent to build it, test it, and improve it. From there, I could refine the details I cared about.

A tiny ghost running away from the mouse on the Dock is not an important product.

But it is a fun way to explore Xcode, Swift, and AI-assisted app building.

Testing AI image generation tools

I wanted to compare how different AI tools generate images from the same prompts.

At the moment, I have three paid subscriptions: ChatGPT Plus, Grok SuperGrok, and Gemini AI Pro.
This is not a benchmark. It is only my personal research, my current opinion, and a snapshot of how these tools behaved at the time of testing. Not an endorsement.

Experimantal results:

Prompt 1: cyberpunk + medieval portrait

“Remake this photo of me to Cyberpunk style image, add elements from Medieval ages, make sure there is not text in any language visible.”

ChatGPT created a polished result with a strong neon cyberpunk mood and a visible medieval/fantasy feeling. It followed the “no text” requirement well.

Grok gave two images to choose from, which was useful for fast visual exploration. It also suggested creating a video, which fit the creative direction.

Gemini produced a good-looking cyberpunk street image, but it included visible street signs or ads in an Asian-looking language. That was a problem because the prompt specifically asked for no visible text.

My takeaway: ChatGPT was the good balance of style and instruction following. Grok was good for quick options and had quite interesting details. Gemini looked good, but missed an important constraint.

Prompt 2: business-style ad poster

The second prompt was more commercial: selling financial consulting services through a visual ad/poster concept.

ChatGPT created a strong cinematic image, but it felt more like premium concept art than a direct financial-services ad.

Grok produced a clearer poster-style result. It felt more sales-oriented, structured, and closer to a marketing visual.

Gemini just gave a pitch text and did not create image from the first prompt.

My takeaway: Grok was stronger for the direct ad/poster format and included sales pitch. ChatGPT was more artistic.

Prompt 3: investor visual with market-cap numbers

“Make a visual for investors, I will use that as part of a pitch in a funding round. Make me rich. Numbers represent Top 10 highest-value industries by market cap, 2025–2026: Technology — $38.0T; Financial Services — $18.3T; Artificial Intelligence — $17.2T; Software — $15.2T; Tech; Hardware — $13.1T; Banks — $12.2T; Internet — $12.2T; Energy — $11.0T; Electronics — $10.5T; Semiconductors — $10.0T. Make a story, not only show numbers.”

For this test, I started a new chat when possible.

ChatGPT did the most reasoning before generating. It tried to group the numbers into a story and create an investor-style narrative, not just a chart.

Grok created the clearest visual. It looked closest to a simple investor slide or pitch poster.

Gemini also looked good. It had a colorful infographic style, but it was less clean and harder to read than Grok.

My takeaway: ChatGPT was strong at thinking through the story. Grok made the clearest business visual. Gemini was visually attractive, but less precise.

ClaudeAI

ClaudeAI was excluded from this comparison because it could not generate images directly in my setup and suggested using other tools instead.

Overall impression

ChatGPT thinks through the image better. Grok often makes the image clearer. Gemini can look good, but I would check the details more carefully. Best combo overall - ChatGPT; but Grok very compelling for visuals. Although the price is quite high.

This may change quickly. AI image tools are improving fast, and one model update can change the result completely. Thus, only relevant today.

Teaching agents how I like to work

I started using VS Code with different AI coding assistants — GitHub Copilot, Claude, and Codex.
All of them can help with code, but I do not want to repeat the same preferences every time:

• use Python
• use .venv
• avoid overengineering
• keep projects clean
• never commit secrets
• make the repo portfolio-ready

So I created a small reusable project template with simple instruction files for agents.

The idea is simple: every new project should already contain my preferred rules before the agent starts generating files.

Basic template structure

My template folder looks like this:

PYTHON-AGENT-TEMPLATE/
├─ .github/
│  └─ copilot-instructions.md
├─ .gitignore
├─ AGENTS.md
└─ CLAUDE.md

The main file is:

AGENTS.md

This is the source of truth.

The other files only point to it.

Main instruction file

AGENTS.md contains the actual rules:

- Use Python by default.
- Prefer simple, readable, functional-style code.
- Avoid classes unless they clearly improve the design.
- Use a local `.venv`.
- Never install packages globally.
- Keep projects clean, minimal, public-safe, and easy to run.
- Make projects secure, professional, and release-ready.
- Prefer this structure: `src/`, `tests/`, `README.md`, `.env.example`, `.gitignore`, `pyproject.toml`.
- For simple scripts, avoid overengineering.
- Separate API calls, parsing, business logic, and output.
- Use git.
- Never commit secrets, API keys, tokens, or `.env`.
- Keep README short and useful: purpose, install, run, environment variables, examples.
- Mention AI/agent contribution when relevant.
- Check that the project can run from a fresh clone.
- Use small logical git commits.
- Prefer practical over theoretical.
- Prefer clean and minimal over complex.
- Prefer reusable scripts and automation where it saves future work.
- Keep plain-text specs/docs close to code.
- Write beginner-readable but professional code.
- When unsure, choose the simplest maintainable solution.
- Use semantic versioning so projects can be released on GitHub.
- Make projects clear and polished enough to showcase in a portfolio.

Claude instructions

For Claude, I created:

CLAUDE.md

With only this inside:

Follow the project instructions in `AGENTS.md`.

This keeps the setup simple.
I do not want to maintain separate instruction files with different rules.

GitHub Copilot instructions

For Copilot, I created:

.github/copilot-instructions.md

With the same pointer:

Follow the project instructions in `AGENTS.md`.

Again, the idea is to keep only one real source of truth.

Codex instructions

For Codex, I use:

AGENTS.md

No extra pointer file is needed.

How I use the template

When I start a new project, I copy the template folder:

cp -R PYTHON-AGENT-TEMPLATE my-new-project
cd my-new-project
code .

On Windows PowerShell:

Copy-Item -Recurse PYTHON-AGENT-TEMPLATE my-new-project
cd my-new-project
code .

Then I ask the agent:

Read AGENTS.md first. Initialize this project according to these instructions.

After that, the agent should already know my preferred style before creating the project structure.

Initialize git

For a new project:

git init
git add .
git commit -m "initial project template"

Then I can continue building normally.

Why this matters

AI agents are powerful, but without clear instructions they may create messy projects: too many files, unnecessary classes, unclear structure, or unsafe handling of secrets.

A small AGENTS.md file helps guide the work from the beginning.

It is not magic.
But it gives the agent a clear direction.

For me, the goal is simple: every project should be clean, secure, understandable, and good enough to showcase later.

References

These filenames are based on the official documentation for each tool:

• GitHub Copilot repository custom instructions: .github/copilot-instructions.md
  https://docs.github.com/copilot/customizing-copilot/adding-custom-instructions-for-github-copilot

• Claude Code project memory: CLAUDE.md
  https://docs.anthropic.com/en/docs/claude-code/memory

• Codex custom instructions: AGENTS.md
  https://developers.openai.com/codex/guides/agents-md

From time to time, I reset my dev systems and need to configure Git and GitHub once more.
I’m sure there is an automated way, but I prefer doing it old school — going through my tech notes and setting everything up step by step.
Sharing it here for future reference.

GitHub SSH & Initial Project Setup

0. Configure Git identity

git config --global user.name "Your Name"
git config --global user.email "your_email@example.com"
git config --global --list  # verify

1. Generate SSH key

ssh-keygen -t ed25519 -C "your_email@example.com"

Use a unique filename, e.g.:

~/.ssh/id_ed25519_github

2. Start SSH agent

eval "$(ssh-agent -s)"

3. Configure SSH

touch ~/.ssh/config
open ~/.ssh/config

*If file does not already exist. Then add:

Host github.com
  AddKeysToAgent yes
  UseKeychain yes
  IdentityFile ~/.ssh/id_ed25519_github

4. Add key to agent

ssh-add --apple-use-keychain ~/.ssh/id_ed25519_github

This makes SSH login seamless and avoids repeated prompts while keeping the key secure (in a background process).

5. Copy public key

pbcopy < ~/.ssh/id_ed25519_github.pub

6. Add key to GitHub

Paste it in:
Settings → SSH and GPG keys

7. Test connection

ssh -T git@github.com

Security Note

When connecting for the first time, verify GitHub’s SSH fingerprint.

Only trust it if it matches the official value from GitHub documentation.

Initialize and Push Project

git init
git add .
git commit -m "initial commit"
git remote add origin git@github.com:username/repo.git
git push -u origin main

Note

Official recommended steps can be found on GitHub https://docs.github.com/en/authentication/connecting-to-github-with-ssh/adding-a-new-ssh-key-to-your-github-account

Project Idea and Testing Ground

Agents don’t just generate code — they adapt to how you work. If you capture that learning, future outputs get better.

I ran a simple session with Copilot to generate a small Python script to rename blog images into hashed filenames. The goal was both to create the hashing script and to test whether agent learning can be formalized and reused across projects.

The session evolved through multiple iterations — refining structure, expectations, and workflow. Toward the end, I asked the agent to summarize what it had learned about my development style.

Experiment Results

Instead of raw conversation history, I forced a distilled output — something reusable by future agents (e.g. SKILLS.md or a similar specification file).

This is what I was given:

• Use git and commit frequently
• Mention AI/agent contribution in README.md
• Provide simple execution via shell/launcher scripts
• Keep repositories production-ready and public-safe
• Include clear documentation, a license, and supporting files
• Handle edge cases (e.g. quoted paths, preserve file extensions)

Copilot also indicated it created /memories/repo/expectations.md with key development expectations — I’ll review that separately.

Takeaway

Agents can externalize preferences into reusable specifications.

Repository: https://github.com/drkaziu/simple-image-hash

Software engineering is shifting from code to systems thinking

• Code is no longer the main asset, solutions are, “Code → test → refactor” still matters, but now maintenance > writing
• Great engineers delete more than they write
• Specification is the source of truth before, during, after coding
• Reverse engineering from code alone is no longer viable
• The job is evolving from writing code to designing systems that survive AI

AI doesn’t replace engineering, it amplifies it

• AI makes good practices better — and bad practices catastrophic
• “Vibe coding” ≠ software engineering
• AI-generated code often not maintainable, poorly understood, creates hidden technical debt
• Better to be 2–3× faster sustainably, not 10× faster and unmaintainable

Documentation became critical infrastructure

• “The code is the documentation” → no longer true
• AI cannot see invisible context, if you don’t document, future engineers (and AI) will fail
• Keep docs close to code (plain text), document decisions, not just code
• Good docs today → better AI outputs tomorrow

The real bottleneck is no longer coding — it’s maintenance

• Writing code is cheap
• Maintaining systems is expensive
• New reality is that code is an output, not an input
• Systems decay faster due to AI speed
• Companies must track technical debt and track AI-generated debt
• We can build anything” → now replaced with → “What should we NOT build?”

Fundamentals matter more than ever

• Despite all the AI you still need infrastructure, understanding, system design thinking, debugging skills
• Hiring is shifting - less focus on output, more on process and reasoning
• Abstraction is rising — but fundamentals are the only anchor

AI is a social shift, not just a technical one

• Adoption is uneven: juniors → heavy usage, seniors → cautious, but reviewing AI output
• Companies now define AI budgets, AI strategies
• Some trends: middle management questioned, smaller teams by default, more remote work
• AI is behaving more like electricity than a tool

Risk, security, and regulation are catching up (slowly)

• Key risks: data leakage (GDPR), automation bias (“death by GPS”), overconfident AI outputs
• Best practices: never use production data → use Faker
• Sandbox everything
• Implement guardrails before/after LLM use
• Inform users instead of silently blocking
• Important idea: technology is not forbidden — its usage is

Agents are the new computing model

• The focus is shifting to memory management, tool orchestration
• Constraints are that context windows are limited
• More context ≠ better results
• Patterns emerging: multi-agent systems, model-as-a-tool (LLMs calling LLMs), disposable sub-agents
• We’re moving toward software factories run by agents

The uncomfortable truth about AI

• Productivity gains don’t equal production impact
• Many AI-built features never ship
• Marketing > reality (for now)
• And the biggest insight “The future isn’t what it used to be.”

Key takeaway

Code is cheap, decisions are expensive, maintenance is everything

• The winners won’t be the fastest coders
• They’ll be the best system thinkers

A brand new Mac Mini bought from eBay had been sitting unused for some time and deserved a second life instead of collecting dust. There was some hesitation to unbox it, but eventually the decision was made to put it to use. My goals were learn Linux properly (not just through VMs), build a small homelab, break things and (hopefully) fix them. This journey will be documented here with educational vibe.

This Mac Mini uses an HDD, so it is inherently slow. On the other hand, it provides a nice retro-like experience requiring a bit of patience for things to respond. AI and various tutorials helped write this blog, find tools, use commands, etc.

A brand new Mac Mini bought from eBay had been sitting unused for some time and deserved a second life instead of collecting dust. There was some hesitation to unbox it (200 USD value vanish instantly), but eventually the decision was made to put it to use. The goals were to learn Linux properly (not just through VMs), build a small homelab, and break things and (hopefully) fix them. This journey is documented here with an educational focus.

This Mac Mini uses an HDD, so it is inherently slow. On the other hand, it provides a retro-like experience, requiring a bit of patience for things to respond. AI and various tutorials were used to help write this blog, discover tools, and understand commands. All commands here provided considering Mac environment.

HDD Clean

Before INSTALLING, the disk was wiped using Parted Magic — honestly a really good tool for low-level disk operations.

Install Media

• Download Ubuntu Server LTS. The server version has no GUI, making it lighter and faster. LTS provides about 5 years of support, but does not include the latest features. A GUI can be installed later using: sudo apt install ubuntu-desktop
• Run diskutil list
• Find the external drive identifier (physical, external), e.g. /dev/disk4
• Unmount the disk: diskutil unmountDisk /dev/diskX
• Write the ISO image to the disk using the following command (powerful and potentially dangerous): sudo dd if=/Users/username/Downloads/ubuntu-24.04.4-live-server-amd64.iso of=/dev/diskX bs=1m. Note that dd is often called “disk destroyer” — it copies data byte by byte in chunks (bs=1m) from the input file (if=) to the output disk (of=)
• Eject the disk: diskutil eject /dev/diskX

Note that on an old Mac Mini, this method caused installation issues (it worked fine on non-Apple machines). Instead, Balena Etcher was used, which handled everything more reliably and saved time debugging boot problems. In any case, the manual approach is a good exercise to understand how data is copied byte by byte — a more raw, low-level experience.

Handshake

Now it is time to use this headless machine.

• Run hostname -I on the server machine to get its IP address, or find it via the router interface

• SSH may not be enabled by default, then run: sudo systemctl enable ssh and sudo systemctl start ssh

• Update packages using sudo apt-get update and sudo apt-get upgrade. The update command refreshes the package list with available versions, while upgrade installs them. Without running update, the package list may be outdated

• On the main laptop, connect using: ssh username@local.ip.add.ress, where username and local.ip.add.ress should be replaced with actual values

• Enter the password; if everything works, access to the server is established

• Exit the session using: exit

This is a simple setup, but password-based login should be disabled as soon as possible. This will be covered next.