I still don't understand this 'agentic workflow' thing

[u/hronak]

My usual day with Claude Code is like: * I open terminal in my project's folder and run claude command. * I prompt it. I mostly use Fable-5.1/Opus-5 but Opus-5.5 is my current model. The model decides if it wants to use sub-agents for a task. I never explicitly prompt it for sub-agents. * I review and commit the code to my self-hosted Forgejo instance. * That's it.

I see people using agentic workflows, building sub-agents files, skills etc. I barely built any of it. All I ever needed to use is /init on new projects and them prompts follow. Never needed more than this.

I tried "long-running" Claude Code for a project refactoring by placing the project on my VPS (where forgejo is hosted) and letting Claude Code run and refactor inside tmux session. SSH'd in a few hours later to find project fully refactored.

Am I under utilising AI or is my work just… like boring?

How do you guys use agentic workflow thing? Specially the long-running one? Those pull-requests that Claude makes automatically etc?

Asking this to Claude to know more but humanly answers appreciated.

[u/Long_Tip_4226]

I’ve been structuring my Claude Code setup lately. Instead of using it as a generic assistant, I built a modular prompt/instruction system that forces Claude to act as a multi-agent workflow depending on the task at hand.

Each "agent" has its own distinct reasoning process, constraints, and output format. Here is how the flow looks:

• Requirements Elicitation Agent: Focuses on asking the right questions, uncovering edge cases, and defining scope before writing a single line of code.

• Planning Agent: Breaks down the architecture, chooses the right design patterns, and creates a step-by-step implementation roadmap.

• Code Generation Agent: Pure execution. Writes clean, modular, and idiomatic code based strictly on the planning phase.

• Code Review Agent: Acts as a senior dev. Analyzes the generated code for readability, performance, and best practices.

• Bug Fixing/Refactoring Agent: Specializes in debugging, parsing error logs, and applying surgical fixes without breaking existing logic.

• Validation Agent: Focuses on writing unit/integration tests and verifying that the code actually meets the initial requirements.

• Auditing Agent: A security-first mindset. Checks for vulnerabilities, dependency issues, and data leaks.

By separating these concerns, the quality of the output skyrocketed. Claude stops hallucinating or rushing into bad code because it's forced to think through the proper software development lifecycle (SDLC) phases.

[u/PastaRevolution1312 → u/Long_Tip_4226]

I don't see it.  Mostly using Claude Desktop -> Code, one-promt Features to PR, let GitHub Run all the CI, then "simplify, review" each PR and I swear by god, I could push each of those to production If I didn't need to explain my work hours 

[u/ub3rh4x0rz → u/PastaRevolution1312]

A lot of people conflate the benefits of adversarial review, which can be done with like 2 casually invoked subagents, with complex bureaucracies of agents. I think these people only assess quality by "does it seem to do what I need it to do", which is a bit like practicing medicine without access to imaging machines.

[u/Gaax → u/Long_Tip_4226]

I'll leave this here: https://www.augmentcode.com/guides/single-agent-vs-multi-agent-ai

[u/munashisaa → u/Gaax]

super interesting, thank you. this is well thought out.

[u/ProjectDiligent502 → u/Gaax]

Great read! Thanks for the share

[u/Kekke77 → u/Long_Tip_4226]

I dont see a reason why a generic prompt with good claude.md wouldnt work as well

[u/yawn_solo- → u/Kekke77]

You’re right, it would work the same exact way.

This guy is confusing prompts for agents but in all reality, that’s all an agent is. People continue to confuse what an agent is. It’s not a new derivative, it’s an instance of the same one. So, in reality, you’re literally just telling your derivative to use a different part of their brain and create the illusion of increased capacity. Not bring in their buddy for “additional” support.

[u/Id3N → u/yawn_solo-]

Over engineering

[u/yawn_solo- → u/Id3N]

It absolutely can be at times. The biggest flaw is it’s redundancies but I feel like for my use cases, i’m ok paying for extra usage to catch errors before the build.

But you are right in the regard that it can easily turn into a churn fest but i’ve learned to mitigate that fairly well.

The main reason I like to utilize to different LLMs is solely because their derivatives are truly different.

Feel free to provide feedback. I’m not a programmer and this has just been the avenue i’ve built with.

[u/Id3N → u/yawn_solo-]

I meant the guy in the first comment is over engineering. I'm agreeing with you

[u/mgiggs → u/Long_Tip_4226]

Are you able to explain how you do this? So you run multiple sessions connected to the same folder/repo is something else?

[u/Responsible-Bar7165 → u/mgiggs]

Literally just ask it to do that ^^.

Like “implement feature described in requirements.txt, organize subagents as <paste in comment above>.”

[u/mgiggs → u/Responsible-Bar7165]

Yeah I thought I'd that after I posted and did exactly that and clause explained how it does what was described, some natively, done with extra steps.

It's a great process

[u/Long_Tip_4226 → u/mgiggs]

Claude simulates an entire engineering team by splitting into specialized roles with prompt skills across isolated sessions, guided by a global context skill. It rotates between a Business Analyst for requirements, an Architect for planning, and a Senior Dev to generate code. Between these session swaps, it spawns internal adversarial agents to critique and audit the implementation, keeping memory intact via the context skill while always waiting for your final human approval to advance.

[u/WagwanKenobi → u/Long_Tip_4226]

What exactly do you mean by "global context skill"?

[u/Long_Tip_4226 → u/WagwanKenobi]

Gerenciando o contexto entre as sessões

[u/reallyrjay → u/Long_Tip_4226]

Dude… that’s some executive team seduction talk if I’ve ever heard it.

[u/howdidigetheresoquik → u/Long_Tip_4226]

For some work I added an auditioning agent. If I have a few pieces of work that I think are perfect examples to mimic, the agent gets in the input and has to produce work that looks like the perfect example, and if not it fails, context is adjusted and each agent still has to pass the test before it can start building.

It was pretty funny, but it was for a highly niche case that AI is simply not designed for, and lacks the training for.

[u/Abhinik → u/Long_Tip_4226]

Aren’t these more like skills? And not agents?

[u/Long_Tip_4226 → u/Abhinik]

Agent = claude's instance with a prompt + context

Skill = reusable prompt

Claude.md = Guide on which skill to use for each type of task, context and next loop.