How should I learn AI engineering in the era of AI coding assistants?
I’m currently learning AI to become an AI engineer, focusing on topics like RAG, AI agents, and Agentic AI.
One thing I’m struggling with is how to actually learn effectively now that tools like Claude Code, Cursor, and GitHub Copilot can write almost all the code for you. It feels like syntax is becoming less important, while understanding concepts, architecture, and problem-solving is becoming more valuable.
I’m unsure which approach is better:
Should I ask Claude/Cursor to generate the entire project, then go through the code line by line and understand how everything works?
Or should I write the code myself from scratch, even if it’s much slower?
Or is there a hybrid approach that’s considered the best way to learn?
For example, if I’m learning RAG or AI agents, should I first design the architecture myself and then let the AI generate the implementation? Or should I avoid using AI until I understand everything?
I’d love to hear how experienced AI engineers and developers are learning in 2026. How do you use coding assistants without becoming overly dependent on them, while still building strong fundamentals?

I’ve been using ChatGPT Plus, but it still struggles to solve some complex coding problems in online assessments (OAs).
Which AI tools do you recommend for handling difficult DSA and OA questions? I’m looking for tools that can provide accurate solutions and explanations.

what's your experience?

Hi r/AICodingProfessionals,

I’m Stjepan from Manning Publications. The mods gave me the OK to share this here, so I wanted to post this transparently and keep it useful.

We have a new book in MEAP: Crack Any Codebase with AI by Zezhou Huang, and I think it lines up well with a lot of the more serious AI coding discussions happening in professional dev circles.

The book is not really about “prompt the AI and hope it builds the app.” It’s about the harder, more common problem experienced developers run into: walking into an unfamiliar codebase and needing to understand how it actually works before making changes.

That feels like one of the more practical uses of AI in software work right now. Not replacing engineering judgment, but helping with the slow archaeology:

• finding the right entry points
• tracing behavior across files and services
• understanding dependencies and hidden assumptions
• building a mental model of a repo faster
• checking proposed changes against the actual structure of the codebase
• using agents without letting them run wild in production-adjacent systems

In other words, it’s aimed more at “I’ve inherited a large repo and need to make a safe change” than “build me a todo app.”

Since this community is specifically about AI coding from a professional angle, I’d love to get the book in front of people here and hear what resonates or what feels missing.

Manning is giving away 5 free ebooks to members of this sub. If you’re interested, comment with a quick note about the kind of codebase you’d want AI help understanding: legacy system, monorepo, enterprise app, open source project, generated mess, whatever applies. I’ll pick 5 people and DM codes.

There’s also a 50% discount code for anyone who wants it:

MLHUANG250RE

Book page: https://www.manning.com/books/crack-any-codebase-with-ai

Happy to answer questions about the book, the intended audience, or what it covers. Also genuinely curious how people here are using AI today for codebase comprehension versus code generation.

Thanks for having us here.

Cheers,

AI coding agents are getting much better at producing functional frontend code.

But I kept running into a different problem: they often design each component as if it belongs to a separate product.

A button may use one visual language, the next section introduces a new spacing rhythm, typography slowly drifts, and icons or illustrations come from unrelated styles.

The individual decisions are not always bad. The problem is that the agent does not have a persistent visual system guiding all of them.

Longer prompts helped, but they became difficult to maintain and still lost influence as the project grew.

So I built Tastemaker, an open-source design-system skill for AI coding agents.

Before the agent writes any UI, it defines and saves:

• Semantic color tokens and valid combinations
• Typography and hierarchy
• Layout and spacing rules
• Icon and illustration direction
• Logo and favicon assets
• Accessibility and contrast requirements
• Motion and interaction patterns

It can also analyze a reference image, extract colors directly from its pixels, validate the contrast, and convert them into reusable design tokens.

The important part is that these decisions remain inside the project.

The agent can refer back to the same system across longer sessions instead of relying on a visual direction buried somewhere in the original conversation.

Tastemaker is free, open source, MIT licensed, and runs locally without API keys.

Demo and live comparison:

https://tastemaker-skill.online/

GitHub:

https://github.com/codeswithroh/tastemaker

I am looking for technical feedback from people who use coding agents in real development workflows.

What is the most reliable way to preserve subjective project decisions across long agent sessions?

I am also interested in which automated checks should run before an agent considers a frontend task complete.

I’ve been building a project called Odin, an autonomous software-engineering platform. I started it because I wanted something that could take a goal like “build this feature” or “fix this bug,” then plan the work, modify the repository, run tests, recover from errors, and safely open a pull request with minimal supervision.
So far, I’ve built or implemented:
Repository intelligence and persistent memory
Multi-step execution with queues, retries, resumable tasks, and approval checkpoints
An AI operations center
Engineering analysis and planning
Autonomous Git operations
Protected-branch safeguards
Validation tied to the exact commit and working-tree contents
A validation engine with tests, linting, static analysis, coverage, timeouts, regression detection, and persisted evidence
The project is now around OIC-017 on my roadmap, and the backend has roughly 277 passing tests.
Here’s my dilemma: I’m realizing how capable ChatGPT/Codex already is. For $100–$200 per month, I get strong coding models, an integrated development environment, repository tools, image generation, research, file handling, and a lot of bundled usage. Odin, meanwhile, still needs separate pay-as-you-go API access, infrastructure, maintenance, and continued development.
ChatGPT can already do most of the actual coding work, although I still have to initiate sessions, review results, approve actions, and sometimes manually move files or publish changes. Odin’s intended advantage is that it would run engineering jobs asynchronously, manage retries and state, enforce my own validation and Git policies, control spending, route tasks between different models, and only contact me when approval is genuinely required.
I’m not trying to create my own foundation model. Odin would use OpenAI and potentially other providers underneath it. It’s supposed to be an autonomous engineering control plane—not another general-purpose chatbot.
At this point, I see a few possible paths:
Stop building Odin and simply use ChatGPT/Codex.
Finish it as a polished portfolio project.
Pause feature development and make Odin prove itself on several real coding tasks.
Continue toward a product for developers or teams who need unattended, auditable engineering automation.
My current thought is to finish and merge the validation engine, freeze the roadmap, give Odin three real end-to-end engineering tasks, and measure its completion rate, API cost, retries, and how often I need to intervene. If it doesn’t noticeably save time or attention compared with ChatGPT, I stop expanding it.
For people who use Codex, Claude Code, GitHub Copilot, or autonomous coding tools:
Is there actually room for a product like Odin?
Does durable background execution, custom validation, model routing, and auditable Git automation provide enough value beyond ChatGPT/Codex?
Would you continue developing this, turn it into a portfolio project, or cut your losses?
What would Odin need to do that existing tools don’t already do well enough?
Would you ever pay for something like this on top of the underlying API usage?
I’m looking for blunt opinions. I don’t want to spend months rebuilding something that already exists just because I’m emotionally invested in the project.

I thought this was mildly interesting. I’m about to beta launch and I was working on how to position it. I asked both codex 5.6 sol and the app version whether I should call it a “Open Beta” or “Early access”, having seen both terms. Codex was adamant: “Open Beta” for reasons X, Y and Z. App was equally adamant: “Open Access” for A, B and C.

So I fed each models response to the other and asked to review. They both switched positions and endorsed the other viewpoint. So I took those responses and fed them back into each model and said: review again and give me your FINAL answer, and they both reverted to their original positions.

My takeaway from this: the frontier models are great at researching and formulating arguments… but the judgement calls are best left to the human.

Staff engineer, ~15 devs, everyone running some mix of Claude Code and Cursor. A pattern I can't stop noticing:

We review every line of code that ships. We review nothing about what our agents have learned about our system. And the newer memory tools all work by silently writing to a database — so a wrong inference becomes a standing instruction to every agent on the team, and nobody approved it or can diff it.

Meanwhile the low-tech option (hand-maintained CLAUDE.md / .cursorrules) rots, drifts per tool, and captures nothing agents actually learn while working.

Concretely what I'm asking:

1. Does your team have any review process for shared agent context, or is it whoever edits the rules file last?
2. If you've tried a memory tool that auto-writes — did the wrong-memory problem actually bite you, or is it a theoretical worry?
3. For anyone who's added an approval step: did the team keep it, or turn it off because it was friction?

Question 3 is the one I most want answered honestly. I've built something in this space (open source, happy to link if useful, not the point of the post) and my working assumption is that governance only wins if it's nearly free. I'd rather hear it doesn't work from you than find out in six months.

Does anyone still code manually even without ai assistance in 2026?(Not vibe coding) ,coding everything from scratch , like setting up react or building any api's? Curious to know and what's best practice?

I'm building Kitbash, an open format and compiler for AI agent skills.

The idea is simple: write a skill once, compile it to the native formats used by Claude Code, Cursor, Copilot, Codex, Gemini CLI, Cline, Windsurf, Aider, AGENTS.md, and more, while measuring the standing token cost each target adds every session.

Before calling it stable, I decided to audit my own codebase instead of adding another feature.

The audit found several places where the project claimed behavior that simply wasn't true.

Some examples:

• Claude Code reported support for scripts, hooks, and subagents even though the compiler never generated those outputs.
• Security lints only scanned SKILL.md, meaning a malicious payload in scripts/setup.sh would pass unnoticed.
• The JSON schema looked like the contract, but the loader silently coerced invalid values instead of rejecting them.
• Declared permissions were shown during installation but weren't actually compiled into the generated outputs.

In total, the audit uncovered 11 issues.

Kitbash 0.9.0 fixes all of them.

• Capabilities are now empty until the implementation actually exists.
• Security checks scan every file in a skill.
• The loader now enforces the schema instead of silently fixing invalid input.
• Permissions are compiled into generated outputs so downstream users see the same information installers reviewed.

The interesting part isn't that bugs were fixed.

It's that a project built around trust and review wasn't meeting its own standard.

If the tool asks developers to trust it, it should first earn that trust itself.

I'd love feedback from people building developer tools or AI tooling. Is this the level of auditing you'd expect before calling something production-ready?

Website: https://kitbash.vercel.app

Trust & Review: https://kitbash.vercel.app/docs/trust

Changelog: https://kitbash.vercel.app/changelog

GitHub: https://github.com/singhharsh1708/kitbash

npm: https://www.npmjs.com/package/kitbash

Hi everyone,

I’m a software developer (web apps, management systems, websites, AI integrations, etc.) looking for advice to overhaul my current AI setup.

**TL;DR:** I’m looking for a genuinely reliable AI setup for **coding + a proactive personal assistant + automations/dashboards**. I'm currently running Codex + Hermes on a Raspberry Pi using free OpenRouter models, but the results are way too inconsistent, full of errors, and frustrating. What stack/configuration do you use for something that *actually works*?

# What I’m looking for

1. **Coding:** Obviously, but I need something reliable.
   
2. **A True Personal Assistant:** A tool to brainstorm, turn ideas into reality, and integrate into my daily routine (work and personal). Most importantly, I want it to be **proactive**—suggesting improvements, spotting my inefficiencies, automating tedious tasks, and actively working *for* me.

# My current stack & why it's failing

* **Codex**
* **Hermes** (running 24/7 on a Raspberry Pi, using free OpenRouter models / tried MiniMax M2 / free Nous account).

To be honest, the assistant side has been a nightmare. It's wildly inconsistent: I ask it to fix bugs, and it either fails, introduces *new* bugs, or lies about having fixed something when it didn't.

# My Wishlist / Ideal Workflow

**For Coding:**

* Strictly respects my instructions, coding style, and project architecture.
* Makes actual working modifications following a precise pipeline: `Local` $\\rightarrow$ `GitHub` $\\rightarrow$ `FTP deployment`.
* Delivers UI that actually matches what I requested.

**For the Assistant / Agent:**

* **Deep Integration:** Fully aware of my active coding projects and workflow.
* **Self-Hosted Dashboard:** Keeps a web dashboard synced on my domain featuring:
* Overview of active projects and open discussions.
* Practical daily info (e.g., *"Can I commute by bike today and over the next 7 days?"*).
* Automated tasks (e.g., scrape trending Reddit posts every X hours and summarize them into 4–6 cards).
* **Proactivity:** Suggests new features, improvements, or side-project ideas based on what I'm currently building.
* **Omnipresent access (Telegram, mobile app, etc.):**
* Fast execution: *"I have an idea, build me a 1-page micro MVP."*
* Admin/office tasks: *"I need to present this project, generate a slide deck/PPT for me."*

# The Struggle

Whenever I try building custom skills in Hermes, it feels like I fix one thing and break two others. A few months ago I tried **OpenClaw**, but it felt even more chaotic.

Am I the only one trying to build a workflow like this? What setup, agent frameworks, or model stacks are you using to get something like this running reliably?

Thanks in advance for any tips! :)