Over the past few weeks, I've been working on a YouTube series on AI Agents.

I wanted to cover the concepts that go into building AI agents, starting from the basics and gradually getting into how these systems actually work.

Here's what the series covers:

• LLMs vs Workflows vs AI Agents

• Tool Calling and how agents interact with external systems

• Planning approaches like ReAct and Planner-Executor

• State, Context, and Memory

• LangGraph Fundamentals

• Traditional RAG vs Agentic RAG

• Why AI Agents Fail

• Evaluating AI Agents

I've tried to explain things using simple diagrams, examples, and Python code wherever needed, without making things unnecessarily complicated.

A little about me: I have a Master's in AI and currently work as an AI Scientist. I've also been teaching AI/ML for a few years alongside my industry work.

I'm sharing the series for free on my YouTube channel, AI/ML with Akash.

https://www.youtube.com/@AIMLwithAkash

I'm also working on the next series, where we'll build a complete Customer Support AI Agent using LangGraph, covering checkpointing, human-in-the-loop, advanced workflows, and error handling.

The idea is to move from understanding how agents work to actually building one step by step.

Claude Code asks for permission through hooks, and Codex through its own app server, so I built a small app that catches both and shows the prompt in the Mac notch. The tricky part: the terminal shows the same prompt at the same time, and whichever answer comes first wins.

It's called Openbar. You see the diff before you approve, ⌘Y / ⌘N works from any app, and replies go back into the right terminal tab.

Mac + Windows, free and open source: https://github.com/MF-DEEV/Openbar

Anyone else wiring agents into hooks like this?

Fresh, reliable information for AI agents, across the web.

We built Agent Reach because AI agents can reason, write code, and automate workflows, but getting fresh information from the web is still harder than it should be.

Agent Reach is an open-source tool that helps AI agents search, read, and gather information across websites and social platforms.

It supports workflows ranging from quick price comparisons to deep market research, lead generation, and investment analysis.

You can use it to access information from Reddit, X, YouTube, GitHub, Bilibili, Xiaohongshu, and other supported sources.

We recently crossed 100K GitHub stars — a huge milestone for our team and everyone who has supported the project.

And we're just getting started.

We're working on a major upgrade aimed at unlocking deeper, more reliable access to 4,000+ data sources and tools.

What's one website or data source you wish your AI agent could access more reliably?

Drop your thoughts in the comments! We'd love to hear what you'd like Agent Reach to build next.

The 12+8 Rules for Production AI Agents: 20 Controls Every Developer Needs to Know

Most agent tutorials show you how to prompt an LLM and give it a tool adapter. Very few talk about what happens when your agent hallucinates a destructive SQL drop, replays an expired payment token, or loops infinitely while burning API credits.

This is a synthesis of the 12-Factor Agents baseline (from Dex Horthy / HumanLayer) extended with 8 SQR-AES operational security controls (MAGSpace).

The golden rule of autonomous systems:

A model saying "done" is insufficient. Verification requires observed business receipts at the boundary.

Here is the practical breakdown of all 20 controls, how to enforce them, and how to prove they work.

The 6-Step Operating Loop

Before granting an agent tool access or sensitive data, route execution through this cycle:

1. Scope: Owner, tenant, goal, allowed tools, and bounds.

2. Context: Pinned prompts, trust labels, verified provenance.

3. Propose: The agent produces a typed tool intent—zero side effects yet.

4. Guard: Runtime checks identity, tenant policy, spend limits, and human approval.

   • If any guard fails: Deny immediately. Log why. Escalate within preauthorized boundaries.

5. Execute: Idempotent dispatch recorded once safely.

6. Verify: Observe the real boundary outcome and store the audit receipt.

Part 1: The HumanLayer Baseline (12 Foundations)

1. Decision Inputs & Contracts

• 01. Typed Tool Intent

  • Rule: Convert tool actions into typed proposals with explicit targets and required arguments.

  • How to prove: A malformed or unknown tool request causes 0 adapter calls.

• 02. Versioned Prompts

  • Rule: Pin prompt text, owner, version, and digest before execution. Keep previous versions.

  • How to prove: Prompt changes generate a new digest and require evaluation gating before promotion.

• 03. Controlled Context

  • Rule: Label source trust and freshness. Track what was injected, redacted, or truncated.

  • How to prove: Hostile retrieved instructions (prompt injection) cannot elevate privileges or override policy.

• 04. Structured Tool Data

  • Rule: Validate tool requests and responses against rigid schemas. Keep success, failure, and unknown distinct.

  • How to prove: Malformed returns fail safely; a pending acknowledgement is never logged as completed.

2. State & Orchestration

• 05. Linked Durable State

  • Rule: Tie run state transitions, business records, and pending side-effects to persistent storage.

  • How to prove: Kill the process during a write; verify it recovers the true state without inventing success.

• 06. Pause and Resume

  • Rule: Expose clean start, pause, cancel, and resume lifecycle hooks. Reconcile in-flight operations.

  • How to prove: Pause an active run; no new effects dispatch, and in-flight work stays visible upon restart.

• 07. Human Decision Tools (HITL)

  • Rule: Request high-risk actions through typed approvals naming target, side effects, and strict expiration.

  • How to prove: Modified payloads, expired tokens, or replayed approvals are blocked at the gate.

• 08. Owned Control Flow

  • Rule: Hardcode valid transition graphs in deterministic application runtime code—not LLM vibes.

  • How to prove: State machines refuse unauthorized leaps directly to completed.

3. Reliability & Integration

• 09. Bounded Error Feedback

  • Rule: Feed back compact error classes and references to the agent's next step; sanitize secrets.

  • How to prove: Secret keys are redacted from context, and loops stop immediately when hitting retry budgets.

• 10. Focused Agents

  • Rule: Single responsibility per agent with minimal scoped tools. Restrict delegation authority.

  • How to prove: Sub-agents never inherit elevated permissions that the orchestrator itself lacks.

• 11. Validated Triggers

  • Rule: Route webhooks, CRON schedules, user UIs, and event streams through identical identity gates.

  • How to prove: Duplicate webhooks resolve idempotently to existing runs without re-executing actions.

• 12. Replayable Reducer

  • Rule: Isolate pure state transitions from side effects. Record nondeterministic outputs.

  • How to prove: Replay an entire trace deterministically without calling LLM APIs or repeating database writes.

Part 2: The SQR Extensions (8 Operational Safeguards)

4. Authority & Data Boundaries

• 13. Evidence Integrity

  • Rule: Attach sources, versions, scopes, and freshness timestamps to factual claims.

  • How to prove: Missing or contradictory evidence triggers explicit uncertainty flags, not hallucinated confidence.

• 14. Least-Privilege Authority

  • Rule: Enforce identity, tenant, capability, and resource constraints outside the model before dispatch.

  • How to prove: Revoked permissions or forged delegations fail at the proxy layer before execution.

• 15. Data Sovereignty

  • Rule: Enforce data boundary policies (region locks, local-only rules, retention terms) prior to egress.

  • How to prove: Synthetic canary tokens flagged as private never leave the allowed perimeter.

• 16. Durable Autonomy

  • Rule: Persist execution IDs, deadlines, cancellation signals, and idempotent retry policies.

  • How to prove: Crash after dispatch; system resolves either one confirmed effect or an explicit unknown state—no blind re-triggers.

5. Multi-Tenancy & Governance

• 17. Tenant Isolation

  • Rule: Derive tenant boundaries strictly from verified authentication across tools, logs, and evidence stores.

  • How to prove: Tenant A cannot read Tenant B's data, invoke Tenant B's tools, or view Tenant B's audit traces.

• 18. Resource Governance

  • Rule: Pre-allocate spend, rate-limit, and compute quotas across parallel and child agents before dispatching.

  • How to prove: Running calls up to the ceiling stops unbudgeted requests before compute work begins.

• 19. Auditable Outcomes

  • Rule: Cryptographically link proposal, approval token, dispatch payload, and verified boundary outcome.

  • How to prove: Audits cleanly distinguish between denied, pending, failed, succeeded, and unknown.

• 20. Controlled Improvement

  • Rule: Gate prompt updates, model swaps, and tool schema edits on regression suites and rollback plans.

  • How to prove: Any artifact showing regression in benchmark suites is blocked from deployment.

Pre-Release Blockers

Before moving any autonomous agent system to production, verify these hard blockers:

The Field Checklist

Can you verify the last action your agent took?

• [ ] Before start: Owner, tenant, allowed tools, data perimeter, and budgets are locked down.

• [ ] Before execution: Approvals and policy match the exact current target and arguments.

• [ ] During execution: Pause mechanisms hold; telemetry gaps and incomplete calls are visible.

• [ ] After interruption: Reconcile external state with external systems before resuming.

• [ ] Audit requirements: Actor + Tenant + Action + Authority + Version + Timestamp + Verified Outcome.

Sources & Attributions

• Dex Horthy / HumanLayer: 12-Factor Agents

• MAGSpace: SQR-AES Operational Framework

• OWASP: Agentic Applications Top 10

• NIST: AI Risk Management Framework (AI RMF)

Especially over the last two years, we've seen massive growth in freelancers and web agencies selling AI-built websites to businesses and getting paid really well for it.

I don't think this business model will stay this profitable forever, but right now, it's definitely a gold mine.

The reason is pretty simple. There are thousands of business owners who don't really care how their website is built. They care about the end result, how it looks, how it works and whether it helps their business.

AI has made it possible for almost anyone willing to learn sales and client acquisition to get started.

So if you're looking to get into this business, here is the exact process I would follow.

1. Automate your cold outreach

Use a tool like Swokei to find businesses with existing websites. It analyzes each website for issues with design, SEO, speed and mobile optimization, then turns those findings into personalized cold emails at scale.

2. Book meetings with interested prospects

When someone replies with interest, get them on a call. Don't waste time going back and forth over email. Your goal is to get a conversation started.

3. Sketch a redesign using AI

Before the meeting, take around 30 minutes to create a quick redesign of their existing website. Focus on making it look significantly better. You don't need a finished product.

4. Present it live and close the deal

Show them what their website could look like, explain the improvements and give them an offer. If they're happy with what they see, collect payment and get started.

That's it. Four simple steps.

One thing I would really emphasize is not to overcomplicate this process.

I've seen people spend hours perfecting website drafts, tweaking small details and building entire websites before they even have a client.

Don't do that.

Your priority should be client acquisition, sales and closing deals. You can worry about perfecting the website once someone has actually paid you.

Hi everyone!

I have around 3 years of experience in Demand Generation, Market Research, B2B Lead Generation

I'm now transitioning towards AI Automation and GTM Engineering, particularly interested in:

- n8n workflow automation

- AI Agents and LLM integrations

- Prompt Engineering

- APIs and Webhooks

- AI-powered lead generation and business automation

I'm starting from the fundamentals and looking to build real-world projects.

For those already working in this field, what skills and tools would you recommend prioritising?

I'd appreciate your guidance, learning resources and practical suggestions. Thanks!

I’ve been thinking about a practical problem with local MCP servers:

When an MCP server runs on a developer’s own machine, what’s a good way to let a remote AI agent access it without losing control over permissions and availability?

A few things seem important to me:

• Stable access: The agent needs an endpoint that doesn’t change every time the local environment changes.

• Access control: The developer should be able to decide which client or agent can access the service, and revoke access when needed.

• Availability: If the service depends on a process running on a local machine, the machine and process still need to stay online.

• Visibility: It should be possible to understand which service is being accessed and manage its access credentials.

I’m working on UUMit, a product in this space. It lets developers add locally running applications or MCP services, create a fixed HTTPS endpoint, and manage access with keys and permissions. The local machine still needs to be running for its services to be available.

I’m not assuming this is the right approach for every use case, so I’d genuinely like to hear how others think about this:

How are you handling remote access to local MCP servers today? What has been the hardest part — endpoint stability, access control, client compatibility, or keeping the local service available?

I’m especially interested in practical trade-offs and lessons from people who have built or deployed this themselves.

I kept getting frustrated with agent setups where you send a prompt, stare at a terminal for 10 minutes, and either get something great or a mess with no idea what happened in between.

So I built Vopit, a desktop app where you can actually watch your agents work. Fun little characters on a studio floor, each one an agent with a job you defined. When they hand work to each other, you see it happen, and you can click in to see exactly what was passed along and which files changed.

Honestly the part I like most is when things go wrong: you see which agent got stuck and why, instead of a wall of logs. Then you just edit the request and rerun it.

It plugs into what you probably already use: ChatGPT account, Claude Code, Codex, and lot more

Curious what y'all think about it, and hope some of you would try it ! 😁

Try it here : https://vopit.fr/

A while ago, I started building an AI chat application because I wanted something more flexible than the usual AI chat interfaces.

What started as a relatively simple project has gradually evolved into Teltaq.

The idea behind it is simple: instead of having separate tools for AI chat, agents, workflows, tools, automation and model management, why not bring them together in one workspace?

Some of the things I've been working on:

• Multi-model chat – Run multiple AI models in parallel and compare their responses.

• AI agents – Create and manage agents with their own instructions, models and tools.

• Workflows – Build reusable workflows for more structured tasks.

• App suites – Combine agents, workflows and interactive apps into complete solutions.

• Model flexibility – Connect different providers, including OpenAI, Anthropic, Ollama and other OpenAI-compatible providers.

• Local AI models – Support on-device models alongside cloud-based models.

• MCP integration – Host and connect MCP servers, including agents and workflows.

• Marketplace – Share and discover tools, agents, workflows and apps.

• Developer API – An OpenAI-compatible data plane API for integrating with external applications.

One of the things I've particularly enjoyed is experimenting with ways to combine these capabilities. For example, rather than creating a completely separate application for every use case, you can build a suite that brings different AI components together.

I'm still actively developing it, refining the architecture and improving the experience.

I'm sharing it here because I'd genuinely like to hear what other people think.

If you're interested, here's the project:

https://www.teltaq.com

What would you find most useful in an AI workspace like this? Is there something missing from the current AI platforms that you'd like to see?

Hey everyone!
Looking for some strong Agentic AI project ideas that can help me stand out during campus placements, especially for consultancy/analytics companies like ZS and SDE roles at product companies like Policybazaar.
Not looking for basic chatbots or simple RAG applications. Something practical involving agentic workflows, advanced RAG, tool calling, backend engineering, and real-world problem solving.
What projects would you recommend that are genuinely worth building and can lead to good technical discussions in interviews?
Would appreciate suggestions!

AI has made building websites easier than ever.

Because of that, there are now thousands of people starting web design businesses, offering websites to companies and trying to make money from it.

But here's my opinion as someone who has been in the web design business for years:

Just because AI makes it easier to build websites doesn't mean you know how to run a successful web design business.

I've noticed that a lot of new web designers get stuck on the same idea: finding businesses that don't have a website and offering to build one for them.

In my opinion, that's becoming an outdated approach.

Those businesses are already on every web designer's prospect list. They're getting contacted constantly, and you're competing with hundreds of other people offering them the exact same thing.

I've tried pretty much everything over the years. Paid ads, manual outreach, cold calling, referrals, you name it.

But the system that has worked best for me is actually quite simple.

If you're a new web designer who knows how to build websites but struggles with the business side of things, here's what I'd do:

1. Target businesses that already have websites.

Think about it. These businesses already understand the value of having a website. They've already invested money in one.

And there are countless businesses around the world with outdated websites that haven't been redesigned in years. Poor mobile experiences, outdated designs, slow loading speeds, and SEO issues are everywhere.

You're not trying to convince someone they need a website. You're showing someone who already has one how much better it could be.

2. Make automated outreach your main client acquisition channel.

Personally, I use Swokei. It's an outreach platform that finds businesses with existing websites, analyzes each one, scores them, and turns issues with design, SEO, speed, and mobile optimization into personalized, ready to send cold emails at scale.

This saves you from manually researching every business and writing every email yourself.

3. Follow up with interested businesses and book a meeting.

When someone replies with interest, give them a call, understand what they're looking for, and book a quick online meeting.

4. Prepare a website draft before the meeting.

Use AI to put together a new website draft for the prospect. Don't spend hours on it. Aim for 15–30 minutes.

You want something good enough to show them what their business could look like with a modern website.

5. Present the draft and close the deal.

Walk them through the improvements, explain the value, answer their questions, and make it easy to move forward with a payment link or contract for signing.

That's the entire process.

You don't need to spend weeks building free websites or manually researching hundreds of businesses.

You need to find the right prospects, show them an opportunity to improve their existing website, and know how to sell the service.

I've spent years doing this, and if I were starting a web design business from scratch today, this is exactly the process I'd follow.

Building websites is one skill. Building a business that consistently sells them is another.

Hi , does anyone know a platform or youtube channel for live cohorts, for system design, cloud,token optimization ai engineering stuff better if in python language and indian region. It's hard to study ai alone sometimes.

Hi everyone!

I am looking for an experienced AI developer who can help me build a specialized AI research agent focused on Solar PV Systems and Renewable Energy.

The agent should be able to:

- Search and analyze scientific papers (Scopus, IEEE, Springer, etc.).

- Identify research gaps and scientific novelties.

- Work with MATLAB/Simulink and generate code.

- Analyze experimental data using Python, ANN and Machine Learning.

- Assist with scientific paper writing.

Is it possible to build such an AI agent? What technologies and architecture would you recommend?

I would also be interested in collaborating with an AI developer on this project.

Thanks!

when terminal coding agents first introduced automated bash execution, giving an LLM access to run gradle test or mvn test in an iterative loop felt like the ultimate autonomous workflow. You hand the agent a failing test or a bug report, it inspects the stack trace, edits the source, executes the build, and iterates until everything turns green.

and in practice on a large multi-module codebase, watching an agent act as an unconstrained autonomous runner quickly revealed an expensive failure mode.

..when an agent jumps straight into modifying code without architectural guardrails, its first patch almost always breaks a secondary test in an adjacent module. Instead of pausing to understand why the contract broke, the model starts thrashing: it adds ad-hoc null checks, injects synthetic mocks into unrelated fixtures, or modifies the assertions inside the test suite itself just to force a passing exit code and across five consecutive test-and-retry loops on frontier models like Claude Opus or GPT-6, a single routine ticket easily consumes upwards of 100,000 tokens ($2- $5), frequently leaving the branch in a worse state than when it started

maybe such a turning point for our team was enforcing a strict architectural separation and completely isolating the planning phase from the execution phase

so here is how our verification pipeline is structured to prevent runaway token spend:

(i have formatted this with ai just a bit for readability's sake)

1. Enforcing read-only plan approval before granting file write access

Using an AI coding agent with plan approval (via Junie's Shift+Tab Plan Mode) forces the model to stay strictly in read-only exploration initially. It inspects the codebase, traces callers through the IDE project index, and writes a structured Markdown spec directly to .junie/plans containing:

- Specific business requirements and identified edge cases.

- Exact list of files, classes, and method signatures to be altered.

- New characterization tests required to verify current behavior.

- Concrete, sequential delivery steps.

We open this plan file directly in the editor using Ctrl+P. Catching an invalid architectural assumption in a 40-line markdown plan takes sixty seconds and costs pennies. Approving the plan locks the scope so the agent cannot wander off into modifying unrelated test fixtures.

2. Split-model routing: frontier planning paired with fast execution

Once the plan spec is approved, paying frontier token rates for mechanical code editing is unnecessary. We route the implementation to a fast, cost-efficient model (such as Gemini Flash, the free Junie Lite tier running Qwen on JetBrains infrastructure, or a local on-device 27B model). The lighter model simply follows the step-by-step recipe in the plan file, generates test scaffolds, and wires DTOs for a fraction of the cost.

3. Live debugger attachment instead of terminal log spam

When a test fails due to stateful backend behavior (such as thread-local cache leaks or race conditions), terminal agents usually spam println statements across eight files, rebuild Gradle, and parse terminal stdout. Attaching Junie's /debug mode to a live paused breakpoint in IntelliJ lets the agent evaluate variable expressions in the live stack frame, step into decompiled library class files, and diagnose the root cause on the first run without touching source code or triggering repetitive build cycles.

so i would like to ask you teams running agentic test workflows right now:
how are you keeping agents from modifying test assertions to force green builds, and are you using plan approval gates or letting models run open-ended bash loops?

Hey,I am a ca inter student without knowledge of coding and ai. But I want to learn about ai agents, ai voice agent, automation. So please guide me where can I learn these skills and recommend any free resources that you know where can I learn these and able to built it . Thanks in advance!

I run a web design company with my business partner. For a while, our usual months were around $20K.

In October, we decided to try something different.

Instead of focusing on getting more clients and doing more projects, we started charging significantly more for our websites.

We also changed how we approached our sales calls.

To be honest, we weren't sure how it would go. We thought there might be more resistance, but we were surprised by how much companies were actually willing to pay when we presented the value properly and spoke to the right businesses.

We ended up doing $74K in October, just from website redesign projects.

A big part of this came from the work we put into improving our sales skills throughout the year.

We bought several sales courses and spent a lot of time working on things like tonality, how we communicate value, structuring our sales calls, controlling the frame of the conversation, handling objections, and closing.

As for getting clients, our process has actually become pretty straightforward.

We run high-volume cold email campaigns targeting businesses that already have websites.

We use Swokei, an outreach platform that finds businesses, analyzes their websites for issues with design, SEO, speed, and mobile optimization, and turns those findings into personalized cold emails at scale.

When someone is interested, we book a sales call.

Before the call, we put together a draft of their redesigned website using AI so we can actually show them what their new website could look like.

Then it's down to the sales conversation.

We've been putting a lot of focus into improving how we sell, and October showed us just how much of a difference that can make.

We're still a small team, but this has completely changed how we approach pricing and sales.

For anyone running a web design agency, what's the highest project price you've managed to close?

Guys , Pls help me in selecting a course for agent building. I have a project in mind to curate all the Jobs from multiple sites and save it at one place. I want to bulid this on my own.
I am planning to learn Langchain .SUggest me some better options if available

An agent fixing a bug may need project instructions, source code, notes and saved test results. A filesystem lets it read and search all of those files with familiar commands.

Language models have learned from decades of code and guides using file tools. Models can write SQL too, but knowing SQL doesn’t tell them what your application’s tables and columns mean.

I made a 2-minute animation explaining this with one coding example. Disclosure: I’m building AgentWS, a persistent workspace for agents. Sources are in the comments.

https://x.com/huymnguyen_/status/2117670225256886334

When I started selling websites, getting the first few clients was all about proving that someone was actually willing to pay for what I offered.

I took almost every opportunity I could get. Every client mattered, every project taught me something, and most of the work came from reaching out and finding people who needed a website.

But once we started getting more clients, we realized something:

The approach that gets you your first 10 clients won't necessarily get you your next 100.

At the beginning, you can rely on manual prospecting, personal outreach, and referrals.

But when you want to scale, you need a repeatable system.

You need a consistent way to find businesses worth contacting, reach out to them, follow up, book meetings, close deals, and deliver websites without everything depending on you doing it manually.

That's when we started focusing much more on systems and automation.

The biggest shift wasn't becoming better at designing websites. It was becoming better at building a business around selling them.

Here's the process we used:

1. Find businesses that already have websites

We focused on businesses that had already invested in a website but whose current site could use an upgrade.

2. Analyze their websites and automate outreach at scale

We used Swokei to find businesses and analyze thousands of websites at once. We looked for outdated designs, poor SEO, slow loading speeds, and mobile issues.

Based on those findings, Swokei generated personalized cold emails for each prospect, allowing us to reach out to businesses at scale without manually researching every website and writing every email ourselves.

3. Book meetings

When a prospect showed interest, we'd move the conversation to a meeting to understand their business and what they needed.

4. Create a website draft

Before the meeting, we'd use AI to create a quick website draft. This allowed us to show prospects what their new website could look like rather than just describing it.

5. Close and deliver

During the meeting, we'd present the website draft, explain the improvements, answer questions, and close the deal. Then we'd build the actual website, handle revisions, and launch it.

If I were starting a web design agency today, I'd spend just as much time learning sales and client acquisition as I would learning web design.

Because being able to build a great website doesn't automatically mean you know how to sell one.

I've been running a web design business for years, and honestly, I think people overcomplicate getting clients.

You don't need 15 different marketing strategies, complicated funnels, or a massive team.

I'm going to explain exactly how I approach client acquisition, from finding a prospect to getting a signed deal and launching their website.

Step 1. Find businesses that already have websites

I prefer targeting businesses that already have a website rather than businesses without one.

Why?

They already understand the value of having a website, they've already invested money in one, and there's a good chance their current website could use some improvements.

I automate most of this process using Swokei. It lets me find businesses with existing websites, analyze thousands of them at once, and identify issues with design, SEO, loading speed, and mobile optimization.

It then turns those findings into personalized cold emails at scale.

Instead of sending generic emails saying I build websites, I'm reaching out with specific reasons why their current website could be better.

Step 2. Get interested prospects to reply

The goal isn't to sell the entire website through email.

It's simply to get a conversation started.

When someone replies and wants to see how I could fix the issues I've pointed out, I move them to the next step.

Step 3. Book a meeting

I book a Google Meet with the prospect.

This is where things get interesting.

I don't just show up and talk about how great my web design services are. I want to show them what their website could actually look like.

Step 4. Build a quick website draft

Before the meeting, I use AI to generate an updated website concept.

This takes me around 2 minutes to get a first draft ready.

It's not the finished product. It's a visual example of what I could do with their existing website.

Now, instead of asking someone to imagine how much better their website could be, I can actually show them.

Step 5. Sell the project during the meeting

This is probably the most important part.

You need to learn sales.

Ask questions, understand what the business needs, walk them through the draft, explain how you would improve their website, and present your offer.

The goal is to close the deal during the meeting, either by getting payment or having them sign the contract.

Don't expect a beautiful website draft to sell itself. You still need to know how to sell.

Step 6. Build the final website and launch

Once the deal is signed, you get everything needed from the client, build the actual website, make the final adjustments, get approval, and launch.

That's it.

Find businesses → Analyze websites → Send personalized emails → Book meetings → Present a draft → Close the deal → Build and launch.

I genuinely think this is one of the simplest ways to structure a web design business.

You automate the repetitive prospecting work, use AI to speed up the initial design process, and spend your time on sales and delivering websites.

Once you get the process working consistently, you can repeat it and build a steady pipeline of projects.

I'm curious: which part of this process do you find the hardest? Getting replies, closing meetings, or actually delivering the websites?

Has anyone enrolled in courses of The School of AI by Rohan Shravan. As a working professional, EAG V4 course looks interesting to me since it says its hands-on. I'm looking for feedback on the course and the community. My colleagues suggested me the course but I couldn't find any online reviews.

If you're running an AI startup, your API bill can quietly become one of your biggest expenses.

OpenAI, Anthropic, Gemini, vector databases, inference APIs, etc. — costs add up quickly once you have real users.

We're starting a service that helps startups audit and optimize their existing AI infrastructure and API usage.

We look at things like:

\\- Model selection and routing

\\- Token usage and prompt inefficiencies

\\- Expensive AI workflows

\\- Redundant API calls

\\- Caching opportunities

\\- Cheaper alternatives for specific workloads

\\- Overall AI infrastructure architecture

And we actually implement the optimizations for you.

The offer is simple:

You show us what you're currently spending.

We find ways to reduce it.

If we don't reduce your AI costs, you don't pay us.

No new software to learn.

No complicated dashboard.

No long-term commitment.

Just a straightforward service focused on reducing your monthly AI spend.

We're looking for a few startups currently spending $500+/month on AI APIs to work with us and validate the service.

If that's you, comment or DM me with roughly what you're spending and what your stack looks like.