Owain Lewis

Be someone who never stops learning.

7 ways to stay relevant in your career:

It's humbling to start over, to learn new things, to suck at something again (I did a lot of that this year).

Do it anyway.

Your career depends on thinking like a beginner.

Here's how to make learning your competitive advantage:

1. Block time for learning

→ Schedule 30 minutes every morning
→ Treat it like a client meeting
→ Never let urgent overtake important

Make learning a routine you can stick to.

2. Learn from people outside your niche

→ Follow experts from different industries
→ Read books that “aren't for you“
→ Have coffee with people who think differently

The fastest way to learn, is to surround yourself with new ideas.

3. Ask the dumb questions

→ Seriously, it's fine.
→ Say “I don't understand“ without shame
→ As a manager, I love these questions.

The smartest people ask the most questions.

4. Build learning systems not goals

→ Create a learning roadmap
→ Track what you learn, not just consume
→ Share your learning to deepen your knowledge

Systems beat motivation every time.

5. Focus on skills that transfer

→ Don't learn “ChatGPT“. Learn LLMs.
→ Principles are timeless
→ Learn to learn

Tactics change. Principles don't.

6. Make failure your teacher

→ Reflect on what isn't working
→ Be willing to experiment
→ Try again with new knowledge

One of my favorite phrases is: “learning experiments“.

7. Stay professionally paranoid

→ Assume your job will change
→ Don't get complacement
→ Don't allow ego to hold you back

Ego keeps you stuck. Humility sets you free.

PS: What do you want to learn more about this year? I'd love to know👇

---

Enjoy this? ♻️ Repost it to your network and follow Owain Lewis for more

People don’t quit jobs.

They quit:

- A bad manager
- A hostile environment. 
- A culture that suffocates them.

Here's how to build a team that thrives:

1. Respect
❌ Don’t dismiss ideas or treat people as replaceable.
✅ Do make people feel valued, heard, and appreciated.

2. Reward
❌ Don’t assume loyalty without recognition.
✅ Do offer fair pay, flexibility, and growth incentives.

3. Challenge
❌ Don’t let people stagnate in routine work.
✅ Do push people beyond their comfort zone to grow.

4. Mentor
❌ Don’t leave people to figure things out alone.
✅ Do provide guidance, coaching, and career support.

5. Trust
❌ Don’t micromanage or exclude.
✅ Do give ownership and involve people in decisions.

6. Empower
❌ Don’t limit their potential or block opportunities.
✅ Do create chances for leadership, growth, and impact.

Retention isn’t about perks. 
It’s about how you treat people when no one’s watching.

PS. What matters most to you?
Let me know in the comments below.

♻️ Repost to remind leaders what really matters.

Follow Owain Lewis

5 years doing the same job isn't 5 years experience.

It's one year repeated five times.

Growing up, I went through phases of practicing music for 8 hours a day (weird I know). It taught me:

You don't improve by mindlessly repeating scales.

You improve by deliberately tackling the difficult passages (deliberate practice).

The same principle transforms your career.

The harsh truth?

Most professionals aren't growing, they're just showing up.

Time spent ≠ skills gained.

Here's how to build genuine expertise and get “unstuck“ in your career:

1. Practice deliberately

• Showing up isn't enough
• Focus on specific improvements
• Deliberate practice makes perfect

The difference between experts and everyone else isn't measured in years, it's measured in deliberate effort.

2. Invest in your skills obsessively

• Poor people buy stuff
• Rich people buy time
• Ambitious people buy skills

Your skills appreciate with time.

3. Embrace strategic discomfort

• Volunteer for projects others avoid
• Master technologies outside your comfort zone
• Seek roles that expose your weaknesses

Comfort feels good but kills growth.

4. Make improvement measurable

• Track progress with specific metrics
• Request feedback from those who won't give you BS
• Review and recalibrate quarterly

Stop counting years.
Start making years count.

How are you ensuring this year isn't just a repeat of your last?

---

Enjoy this? ♻️ Repost it to your network and follow Owain Lewis for more.

16 Claude Code tips to become a superhuman developer

(most engineers don't know these exist):

After 20 years in software engineering, I've learned: the right systems don't just speed you up, they multiply your output.

Claude Code is one of those tools.

But most developers barely scratch the surface.

16 tips to unlock its full potential:

1/ Create a CLAUDE.md file in your project root

Put your coding standards, workflows, and environment setup in one place. Claude reads this automatically and follows your conventions.

2/ Use Git worktrees for parallel tasks

Run multiple Claude Code sessions without context bleed.

3/ Define specialized sub-agents in /agents

Security reviews, database tasks, UI work—each gets its own agent.

4/ Build custom slash commands in .claude/commands/

Store markdown prompts and invoke them with /command. Great for repeat workflows.

5/ Ask for "plan first, code second"

Tell Claude to create a detailed plan before implementation. Review and approve before it writes a line of code.

6/ Provide structured context and instructions

Give Claude role, constraints, and examples. The better your prompt, the better the output.

7/ Use headless mode for automation

Run Claude in CI/CD with -p flag and --output-format json.

8/ Let Claude see images and screenshots

Paste screenshots for UI bugs, diagrams, or designs. Visual context dramatically improves debugging.

9/ Use thinking depth keywords strategically

Say "think", "think hard", or "ultrathink" for complex problems. Triggers deeper reasoning when you need it.

10/ Auto-generate commit messages

Let Claude summarize diffs and write clear commit messages. Still validate them, but save yourself the mental overhead.

11/ Keep documentation in sync

Auto-update README and CHANGELOG based on code changes. This is an awesome use for AI.

12/ Integrate with GitHub workflows

Use gh CLI to trigger Claude on issues, PRs, and reviews.

13/ Run it anywhere you need

Terminal, SSH session, CI/CD, remote server. Not locked to one IDE or environment.

14/ Limit tool permissions carefully

Curate the allow-list and request permission for system changes. By default, Claude requests approval for anything that modifies your system.

15/ Use /clear to reset context when switching tasks

Clean slate for new problems without restarting. Keeps your context window focused and relevant.

16/ Use Claude for Git operations

Generate commit messages, summarize diffs, query history. Let Claude handle the version control grunt work.

---

If you found this useful: ♻️ repost it to your network and follow Owain Lewis for more.

PS: if you want to master AI and software engineering, I share weekly tutorials, lessons, and deep dives in my newsletter. Get it free here https://lnkd.in/e7Ymdh_j.

Have an awesome day 🙏

If you want to master Git as a software engineer, learn these 10 commands.

Most engineers know git add, git commit, git push.

Here are the 10 commands that unlock everything else:

1. git worktree

Run two Claude Code sessions without losing context. Creates a second folder on a different branch for urgent fixes while your main Claude keeps working.

Example: git worktree add ../hotfix

2. git stash

Save work with context you'll remember later. Future you won't remember what "WIP" meant.

Example: git stash push -m "auth refactor"

3. git rebase

Clean up messy commits before anyone sees. Turn "fix", "fix again", "oops" into one clean commit.

Example: git rebase -i HEAD~3

4. git reset

Undo last commit, keep all changes. Perfect for "committed too early" moments.

Example: git reset --soft HEAD~1

5. git cherry-pick

Copy one commit to your current branch. Move that critical fix without merging 47 other commits.

Example: git cherry-pick a1b2c3d

6. git reflog

Time machine for Git mistakes. Git remembers everything for 90 days. You can't lose commits.

Example: git reflog

7. git bisect

Find which commit broke things. 200 commits → 8 tests. Turns 2 hours into 10 minutes.

Example: git bisect start, git bisect bad, git bisect good v2.0.0

8. git log

Visualize your branch structure before merging or rebasing.

Example: git config --global alias.tree "log --oneline --graph --all"

9. git diff

Catch debug code before production. Shows what you're about to commit.

Example: git diff --staged

10. git commit --amend --no-edit

Add forgotten files to last commit. Only use before pushing.

Example: git add file.js, git commit --amend --no-edit

---

PS: I run a weekly newsletter for software engineers who want to build systems with AI: Get it here: https://lnkd.in/eQkMB_bz

Repost ♻️ and follow Owain Lewis for more.

If you're serious about building distributed systems, learn these 7 DNS concepts:

DNS looks simple on the surface: google.com => IP address.

But DNS (Domain Name System) is a masterclass in distributed systems engineering that keeps the entire Internet running.

1. Multiple servers solve an impossible problem

DNS uses a hierarchy where each layer knows just enough to point you to the next:

Root → TLD → Authoritative

Root servers: know TLD name servers
TLD servers: know authoritative servers for each domain
Authoritative servers: store DNS records

Try it: dig +trace google.com

2. Caching is everywhere

DNS would collapse without caching.

Answers are cached in:
✓ Browsers
✓ Operating systems
✓ Resolvers

If the resolver already knows the IP from cache, it skips the hierarchy entirely.

Try it: dig google.com +noall +answer

TTL tells a cache how long it can reuse an answer before checking again.

3. DNS is eventually consistent

Changing a DNS record ≠ instant global update.

Old values stay valid until TTL expires.

This is why DNS changes sometimes take hours to "propagate."

DNS chooses availability and speed over instant consistency.

4. DNS uses UDP for speed

Most DNS queries use UDP:

✓ Single request/response
✓ No handshake overhead
✓ If lost → client retries

Compare:
dig google.com (UDP)
dig +tcp google.com (TCP)

Speed matters at Internet scale.

5. DNS stores multiple record types

Common records:
- A → IPv4 address
- AAAA → IPv6 address
- CNAME → alias to another hostname
- NS → nameservers for a domain
- MX → mail server routing

Try it:
dig google.com A
dig google.com MX
dig google.com NS

6. Your DNS resolver matters

Most people use their ISP's default resolver.

But you can choose:
- 1.1.1.1 (Cloudflare) → privacy-focused, doesn't log
- 8.8.8.8 (Google) → fast global network, logs for analytics

Check yours: dig google.com | grep SERVER

7. DNS is a blueprint for distributed systems

DNS teaches you how to build systems that scale:

✓ Hierarchical design 
✓ Eventual consistency enables global scale
✓ Fault tolerance through replication

Which concept surprised you most?

---

PS: Want to level up your systems thinking and AI engineering skills?

Join the AI engineer community for hands-on learning: https://lnkd.in/eJA9HM4V

Enjoy this? ♻️ Repost it to your network and follow Owain Lewis for more.

Claude Code Skills vs MCP vs Sub-agents vs Commands vs Hooks:

When do you use which?

Here's the breakdown:

1. Custom slash commands

These are the primitive.

→ Manual triggers you control
→ Reusable prompt shortcuts
→ Closest to bare metal prompting

Everything is just a prompt in the end.

2. Skills

When one prompt isn't enough, scale it into a skill.

→ Agent-triggered (autonomous)
→ Context efficient (progressive disclosure)
→ Modular file structure

Use when: You have more complex SOPs, large context, scripts/resources (not just execute one task).

3. MCP

Connecting Claude to outside tools and data.

→ Third-party services
→ Databases
→ API connections

These are for talking to external tools/services.

4. Sub-agents

Isolate context, work in parallel.

→ Multiple tasks at once
→ Don't need the context afterward
→ Separate execution environments

The only feature that supports true parallelization.

5. Hooks

Execute commands at specific lifecycle events.

→ Adds determinism to agent workflows
→ Balance between agent autonomy and control
→ Triggered by events, not prompts

The key principle:

Everything is a prompt but each feature has a different purpose.

Which features are you using most?

---

PS: I break down AI engineering tactics like this every week in my newsletter: https://lnkd.in/e7Ymdh_j.

Enjoy this? ♻️ Repost it to your network and follow Owain Lewis for more.

Have an awesome week : )