u/BoringContribution7

I moved from the UK to the UAE a few months ago, and there’s a decent chance I’ll relocate again in the next couple of years, so I’ve been rethinking how I’ve set up my investments.

It was simple when I started, but once you change countries, things like accounts tied to residency, different currencies, and even just keeping track of everything start to get messy pretty quickly.

I’m trying to avoid rebuilding everything from scratch every time I move, but not sure what people generally do once they’re a bit more mobile. Ideally just looking for something that holds up without too much friction across countries.

An agent is a loop. The model reads your goal, picks a tool, runs it, reads the result, picks the next tool. It stops when the work is done or it hits a wall. That's the entire mechanism.

Every framework you'll see, the Claude Agent Software Development Kit, OpenAI Agents, LangChain, CrewAI, wraps that loop. Pick one later. Don't make it your first decision.

Three pieces sit under the loop:

A model that supports tool calling, where the model fills in a small form asking your code to do something. A handful of tools, each doing one specific job and returning a clean result. A few lines of glue code asking the model what it wants next, running it, handing back the result.

That's it.

how to build

Write the goal in one paragraph. Three sentences. What does the agent do, who's it for, what does success look like. Five minutes. Skip this and the agent will end up doing something adjacent to what you wanted.

List the tools. A tool is a small function that does one job and returns something tidy. Four tools is comfortable. Past six the model starts picking the wrong one. If you don't know how to write the function, ask the model. The thinking work is choosing what belongs on the list.

Pick the runtime. Two options. A code-first kit where you write a Python or JavaScript file and the kit handles the loop, retries, and memory. Or a markdown-first runtime where you describe the agent in plain English, point it at your tools, and run it. Same shape underneath.

Write the system prompt. Three sections that work: what the agent does in plain language, the tool list with when to use which, and what to do when something fails or the input is empty.

Run it on one example. Watch where it stumbles. Edit the prompt. Three or four passes and the loop runs clean. Most of the build time lives here, almost none in the code.

Five things to take care of

Make tools return a summary plus the result. Without the summary the model loses track of what it just did and starts repeating itself two steps later.

Use plan mode. Have the agent lay out the steps before acting. Read the plan, approve it, let it execute. Most "weird agent behavior" disappears once the plan is visible.

Wire a kill switch and a notification on every run. If a loop goes sideways at 3am you want to know by 3:01.

Keep the tool list short. If you need ten tools, build two agents.

Log every run. What was tried, what came back, what failed. When something breaks the log is the only thing that helps.

What to build first

Pick something boring enough to ship in an afternoon. A research helper that drafts one-page briefs on a list of topics. A triage helper that skims a noisy channel and writes a digest. A housekeeping agent that tags stale tickets and posts a weekly summary.

Most of the VibeCoding has moved on from Vibecoding to agentic engineering. More oversight. More scrutiny. The person who coined vibe coding moved on from it.

The difference

Vibe coding means going with the vibes and not reviewing the code. That's the whole definition. You prompt, accept, run, see if it works.

Agentic engineering means the agent does the implementation and you own the architecture, the correctness, and the review. You might write a small fraction of the code by hand. The rest comes from agents working under your direction, and you apply engineering discipline at every step.

Same tools. Different operator.

One line: vibe coding is YOLO, agentic engineering is "agent builds, human owns."

Why vibe coding broke at scale

Three failure modes killed it in production work.

Security holes compound. An agent writing 1,000 pull requests a week at a 1% vulnerability rate ships 10 new vulnerabilities every week. Vibe coding has no gate for this because the human isn't reading what gets merged.

Architecture rots. Skipping the design phase means three months later nobody can explain why the codebase is shaped the way it is. There's no reasoning to follow because no reasoning happened.

Context collapses. Long sessions degrade. The agent loses track of earlier decisions, code starts contradicting itself, and the developer never catches it because they aren't reading the diffs.

The accumulated cost of all this is cognitive debt: the price of poor agent management, lost context, and unreliable behavior. Vibe coding produced it faster than any prior workflow.

What agentic engineering looks like in practice

Step 1: Write the spec before prompting anything.

What does the feature do. What are the edge cases. What does the data model look like. What can break. This is the step vibe coders skip, and it's the one that decides whether the agent produces working code or plausible-looking garbage. Use the model to help you draft it if you want, but the spec exists before the agent touches a file.

Step 2: Break it into scoped tasks.

"Build me a user authentication system" is a vibe coding prompt. Too large, too vague, and the agent will make architectural calls you never agreed to.

A scoped task looks like this: "Implement the password reset email flow using our existing Resend integration. Store the token in Redis with a 15-minute time-to-live. Here's the spec."

Constrained. Reviewable. The agent can't drift.

Step 3: Review the diff like it's a human pull request.

If you can't explain what a module does, it doesn't merge. Agents produce code faster than you can read it, and the temptation to skim and approve is exactly what produces the unmaintainable codebases people complain about. Read the diff. Ask the agent to explain anything you don't follow.

Step 4: Test before shipping.

Vibe coding ships when something looks like it works. Agentic engineering ships when tests pass, tests you wrote or reviewed, not tests the agent generated and you skimmed.

If the tests don't exist, write them first. Make the agent pass them.

The shift

You're not the person typing the code anymore. You're the person who decides what gets built and why, designs the architecture the agent operates inside, reviews what comes back, and decides what ships.

The value isn't typing speed or knowing every parameter from memory. It's clarity in defining problems and accuracy in judging results. The developers who do well here are the best architects and the most rigorous reviewers, not the fastest prompters.

Three habits to change this week

Write a spec before every agent task, even one paragraph of bullets. The act of thinking before prompting is what separates the two workflows.

Read every diff. If the agent changed 200 lines, you read 200 lines. Nothing merges until you can explain it.

Run the tests before calling anything done. No tests means write them first, then have the agent make them pass.

Three habits, same tools, different outcomes.

I’ve always kept my crypto and stocks on completely separate platforms, mainly because that’s how I started and it felt like the “right” way to do it.

But lately it’s starting to feel inefficient. Tracking performance across both isn’t straightforward, and it’s harder to get a clear picture of my overall allocation without manually piecing things together.

At the same time, I get why people keep them separate, different tools, different risk profiles, etc.