Çok sayıda otomobil devini çatısı altında barındıran Stellantis, bugün küçük ve erişilebilir yeni elektrikli araç projesini duyurdu. Bu konuda şirketten yapılan açıklamada, “Stellantis, yeni nesil projeleriyle ve yatırımlarıyla sürdürülebilir büyüme hamlesini desteklemeye devam ediyor. Bu kapsamda şirket çığır açan, küçük ve erişilebilir elektrikli araç projesi E-Car’ın hayata geçirildiğini duyurdu. İlk E-Car modellerinin 2028 yılında üretim hattından çıkması hedefleniyor. Stellantis, E-Car’daki “E” harfinin; European (Avrupalı), Emotion (Duygu), Electric (Elektrikli) ve Environmental friendliness (Çevre Dostu) kavramlarını temsil ettiğini açıkladı. Avrupa’da Avrupalılar için üretilecek bu yüksek potansiyelli segment, Avrupa Komisyonu tarafından; Avrupa’daki tasarım ve üretim istihdamını destekleme potansiyeli taşıması ve günlük şehir içi mobilitede tamamen elektrikli araçların daha geniş çapta benimsenmesine katkı sağlaması nedeniyle önemli bir proje olarak değerlendiriliyor. E-Car; Avrupa’daki küçük ve erişilebilir otomobil segmentinde son yıllarda yaşanan ciddi daralmaya çözüm sunmak amacıyla, Avrupa’nın “halk için mobilite” geleneğine sadık kalınarak geliştirilen; küçük, yenilikçi, erişilebilir ve tamamen elektrikli bir araç olarak öne çıkıyor. […]

Stellantis, küçük ve erişilebilir yeni elektrikli araç projesini duyurdu yazısı ilk olarak Teknoloji haberleri – LOG üzerinde yayınlandı.

I don’t offer SEO as a service. But every site I build ships with technical SEO baked in — because it’s not marketing, it’s engineering. A site that search engines can’t crawl or understand is a site that doesn’t work properly. In the pikkuna.fi e-commerce build, that meant correct hreflang across 30 languages, server-rendered product pages, and JSON-LD that survived localization. Same principles, scaled up.

slug=”mvp-development”
text=”Building a Next.js project that needs to rank from day one? SSR, structured data, and sitemaps are part of what I ship — not add-ons.”
/>

Server-Side Rendering by Default

Single-page apps with client-side rendering are invisible to most crawlers. Every project I build uses Next.js App Router with server components:

// app/products/[slug]/page.tsx
export default async function ProductPage({
  params
}: {
  params: Promise<{ slug: string }>
}) {
  const { slug } = await params;
  const product = await getProduct(slug);

  return (
    <article>
      <h1>{product.name}</h1>
      <p>{product.description}</p>
    </article>
  );
}

The HTML arrives fully rendered. No JavaScript required for indexing.

Dynamic Meta Tags

Every page gets proper meta tags generated from actual content:

// app/products/[slug]/page.tsx
export async function generateMetadata({
  params,
}: {
  params: Promise<{ slug: string }>;
}): Promise<Metadata> {
  const { slug } = await params;
  const product = await getProduct(slug);

  return {
    title: `${product.name} | Store`,
    description: product.description.slice(0, 160),
    openGraph: {
      title: product.name,
      description: product.description,
      images: [product.image],
    },
  };
}

This handles SEO meta tags, Open Graph for social sharing, and Twitter cards — all from one function.

JSON-LD Structured Data

Schema.org markup tells search engines exactly what the content represents:

function ProductJsonLd({ product }: { product: Product }) {
  const schema = {
    "@context": "https://schema.org",
    "@type": "Product",
    name: product.name,
    description: product.description,
    image: product.image,
    offers: {
      "@type": "Offer",
      price: product.price,
      priceCurrency: "EUR",
      availability: "https://schema.org/InStock",
    },
  };

  return (
    <script
      type="application/ld+json"
      dangerouslySetInnerHTML={{ __html: JSON.stringify(schema) }}
    />
  );
}

I add appropriate schemas based on content type: Product, Article, Organization, FAQPage, BreadcrumbList.

Automatic Sitemap Generation

Next.js can generate sitemaps from your data:

// app/sitemap.ts
export default async function sitemap(): Promise<MetadataRoute.Sitemap> {
  const products = await getAllProducts();

  return [
    { url: "https://example.com", lastModified: new Date() },
    ...products.map((p) => ({
      url: `https://example.com/products/${p.slug}`,
      lastModified: p.updatedAt,
    })),
  ];
}

No plugins, no external services. Just code that generates /sitemap.xml at build time.

This isn’t optimization work you hire someone for later. It’s the baseline for a properly built website. When I deliver a project, the technical SEO foundation is already there — because skipping it means shipping broken software.

If you want to go further with the indexing layer, read IndexNow in Next.js: Instant Indexing After Every Deploy and llms.txt for AI Discoverability. Together with the patterns above, that’s the full stack.

slug=”seo-audit”
text=”Want this same checklist applied to your existing site? Fixed-fee Technical SEO Audit — keyword research per market, schema, sitemap, hreflang, Core Web Vitals, indexing, broken links, OG images — delivered as a prioritised written report in 5 working days.”
/>

For MVP development with this foundation built in from the start — get in touch.

If you use Claude Code with more than one account – personal and work, or one per client – you know the dance. claude opens, you realize you’re under the wrong account, you /logout, /login, sit through the OAuth browser flow, then forget which account you’re in by the time you switch projects again.

I built claudenv to make this stop happening.

claudenv use work
claude   # automatically under your work account

cd ~/projects/clientA
# auto-switches if you opted in, or:
claudenv use personal

That’s it. The same claude binary, just pointed at different config directories via the official CLAUDE_CONFIG_DIR environment variable. No symlinks, no patching files in place, no daemons.

How it works

Claude Code reads its config from ~/.claude by default, but respects CLAUDE_CONFIG_DIR if set. claudenv keeps one directory per account under ~/.claudenv/accounts/<name>/ and points the env var at the right one. Each account has its own OAuth state, settings, MCP servers, the whole thing.

There are three layers of state, exactly like nvm:

• Global default – what you set with claudenv use work, persists across shells
• Per-project override – a .claudenvrc file in your repo, picked up via walk-up resolution like .nvmrc
• Shell-session override – .claudenvrc auto-switches on cd if you enable the hook
  Set a default, override per-project, forget about it.

Why not just claude-switch or claudectx?

There are other tools in this space – I want to be upfront about that.

claude-switch uses the same CLAUDE_CONFIG_DIR mechanism, but the workflow is per-launch: claude-switch work runs Claude under that profile, every time you start a session. If you prefer being explicit on every invocation, use it – it’s a fine tool.

claudectx and a few others go a different route entirely, symlinking or patching ~/.claude.json in place. That works too, but it’s stateful in a way I didn’t want. If the symlink breaks or a patch fails halfway, you end up in a weird state that’s hard to debug.

claudenv is for people who switch accounts more than once a day and don’t want to type the profile name every time. If your projects are clearly tied to specific accounts, .claudenvrc + auto-switch means you basically never think about it again.

Install

curl -fsSL https://raw.githubusercontent.com/bodasooqa/claudenv/main/install.sh | bash

Or with wget, or download and inspect first – instructions are in the README.

Bash or zsh, that’s the only requirement. No Node, no Python, no Homebrew, no extra dependencies. Twenty lines into ~/.zshrc, you’re done.

What’s next

A few things on the roadmap: a claudenv self-update command, a Homebrew tap once there’s a real release cadence, and a wrapper that makes GUI-launched IDEs (Cursor, VS Code from the Dock or Spotlight) pick up the active profile – currently that’s a known limitation with launchd not reading shell rc files, documented in the README.

If it solves your problem, a star helps me prioritize what to build next. Issues and PRs welcome.

claudenv import default       # save current ~/.claude as 'default' (auto-activated — first profile)
claudenv add work             # create new empty slot
claudenv use work             # switch this shell + set as global default
claude                        # /login here, isolated from 'default'

Why I stopped hand-assembling content

I got tired of copy pasting my way through content.

Idea in Notion. Outline in Docs. Draft in ChatGPT. Formatting in Ghost. Images in Figma. Every post felt like a manual QA job instead of building something once and letting it run.

So I pushed the whole thing into Make.com.

Now a single row in Google Sheets turns into a drafted or published Ghost post. Titles, meta fields, tags, even a first-pass excerpt. All wired together with OpenAI in the middle.

This is the exact blueprint. Not theory. This is the scenario that runs my real content pipeline.

The high-level architecture

The stack is simple on purpose:

• Google Sheets as the content control panel.
• Make.com to orchestrate everything.
• OpenAI to generate and clean up text.
• Ghost (self-hosted) as the CMS.

One sheet row = one post. Status and flags in that row decide if Make should ignore it, draft it, or publish it.

I keep the Make scenario focused. One job. Turn structured data in Sheets into structured content in Ghost.

The Google Sheet schema

Here is the actual column setup from my sheet. No fluff.

• A: id – internal ID, just an incrementing number.
• B: status – idea, ready, generated, published.
• C: title – human-written title seed.
• D: slug – usually auto-generated in Make if empty.
• E: brief – 2–4 bullet outline or a short paragraph.
• F: target_keywords – comma separated SEO terms.
• G: tone – e.g. direct, informal, first-person.
• H: word_count_goal – rough length like 1200.
• I: tags – comma separated Ghost tags.
• J: generated_html – where I store the body HTML from OpenAI.
• K: meta_title
• L: meta_description
• M: excerpt
• N: publish_flag – draft or publish.
• O: ghost_post_id – for updates.

I do not trust LLMs to guess intent. So I give them a tight brief and flags.

The Make.com scenario: the main flow

I run a single Make scenario that does all of this:

• Polls Google Sheets for new ready rows.
• Generates content and meta fields via OpenAI.
• Writes the generated content back into the sheet.
• Creates or updates a Ghost post.
• Updates status and IDs.

I will walk through every module and what it actually does. No hand waving.

Module 1: Google Sheets “Search Rows”

Trigger: I run this scenario on a schedule. Every 15 minutes works for my pace.

First module is a Google Sheets > Search Rows module.

• Spreadsheet: my Content Pipeline sheet.
• Sheet: Posts.
• Filter: status = ready.
• Limit: I cap at 3 rows per run. I prefer small batches.

This returns an array of rows that are ready to be turned into drafts.

Each row carries all the columns I mentioned earlier.

Module 2: Iterator

I drop an Iterator right after Search Rows.

No magic here. It splits the list of rows into separate bundles so I can process each post independently.

The iterator just takes the array of rows from Sheets and iterates over values[].

Module 3: Data cleanup with Text & Tools

I do some pre-processing before I hit OpenAI.

• Trim whitespace from things like title and slug.
• Normalize commas in tags and target_keywords.
• Generate a fallback slug if the cell is empty.

In practice this is a couple of Tools > Text aggregator / Text parser modules and one Set variable module.

Example: to generate the slug I use a simple Make formula in a Set variable module:

lowercase(
  replace(
    replace(
      replace(
        stripDiacritics(title);
        " "; "-"
      );
      "--"; "-"
    );
    "[^a-z0-9-]"; ""
  )
)

If the slug column in Sheets is already filled, I keep it. Otherwise this kicks in.

Module 4: OpenAI “Create a chat completion” for the article body

Now the fun part.

I use the OpenAI > Create a chat completion module. Currently on gpt-4.1 but I keep this modular so I can swap models.

I feed it a structured prompt that merges sheet data and my own style instructions. Here is the actual system + user content simplified to fit here.

System message (in the module):

You are Richard Lemon, a creative web experience developer.
Write opinionated first-person blog posts.
No em dashes. Short paragraphs (max 2-3 lines).
Direct voice, practical, specific.
Use HTML with <h2>, <p>, <ul>, <li>, <pre>.
Do not add <html> or <body> tags.

User message template:

Write a blog post with the following constraints:

Title: {{title}}
Brief: {{brief}}
Target keywords: {{target_keywords}}
Tone: {{tone}}
Word count target: {{word_count_goal}}

Rules:
- Write in first person as if I actually did the thing.
- Be concrete and technical where useful.
- Use only HTML tags for structure (<h2>, <p>, <ul>, <li>, <pre>, <code>).
- No introduction fluff, start with context or action.
- No conclusion heading.

Return only the HTML body.

The output is pure HTML. I do not want Markdown here because Ghost accepts HTML just fine and I like having precise control.

Module 5: OpenAI for SEO meta + excerpt

I split generation into two calls instead of asking one model response to do everything.

Second OpenAI > Create a chat completion module takes the title, target keywords, and a short summary of the generated HTML and creates meta fields plus an excerpt.

System message:

You create SEO metadata for blog posts.
Always stay under the specified character limits.
Return JSON only.

User message:

Post title: {{title}}
Target keywords: {{target_keywords}}
Body HTML (truncated): {{body_preview}}

Generate:
- meta_title: max 60 chars, must include at least one keyword.
- meta_description: 120-155 chars, natural and specific.
- excerpt: 1-2 sentences, no clickbait.

Return JSON like this:
{
  "meta_title": "...",
  "meta_description": "...",
  "excerpt": "..."
}

I then parse that JSON with a JSON > Parse JSON module.

Could I compress this into one call? Sure. I tried that. The meta fields got worse and harder to constrain. So I split it.

Module 6: Write everything back to Google Sheets

At this point I have:

• Cleaned title and slug.
• Generated HTML body.
• Meta title, description, and excerpt.

Before touching Ghost I push this back into the sheet.

I use Google Sheets > Update a Row with:

• Column J → generated_html from OpenAI.
• Column K → meta_title from JSON.
• Column L → meta_description.
• Column M → excerpt.
• Column D → final slug.
• Column B → set to generated.

Why write back before publishing?

Because I like a manual checkpoint. I can read the generated HTML in Sheets, tweak the brief or title, flip status back to ready if I want a regen.

This effectively makes Sheets my content staging area while Ghost stays clean.

Module 7: Filter on publish_flag

Not every generated post should go live.

I add a filter between the Sheets update and the Ghost modules:

• publish_flag = "draft" OR publish_flag = "publish"

If publish_flag is empty or something else, the scenario stops for that row. It will still update the generated fields, but nothing touches Ghost.

When I want a post to move to Ghost I set publish_flag to draft or publish in the sheet.

Module 8: Router for create vs update in Ghost

I use Ghost both for new posts and edits triggered from Sheets.

So I drop a Router with two branches:

• Branch 1: Create when ghost_post_id is empty.
• Branch 2: Update when ghost_post_id is not empty.

This lets me tweak a title or tags in Sheets, set publish_flag again, and push an update to the existing Ghost post.

Module 9: Ghost “Create a post” (branch 1)

On the create branch I use the Ghost > Create a post module.

Here is how I map things:

• Title → Sheet title.
• Slug → final slug from Module 3.
• HTML → generated_html.
• Excerpt → AI generated excerpt.
• Meta title → meta_title.
• Meta description → meta_description.
• Tags → split tags column on comma, trim each value.

For status I map directly from publish_flag:

• draft → Ghost draft.
• publish → Ghost published.

Ghost returns a post object with an id. I capture that and write it back to the sheet.

Module 10: Google Sheets “Update a Row” with ghost_post_id

Immediately after the create call I drop another Google Sheets > Update a Row module.

It takes the id from Ghost and stores it in column O: ghost_post_id. I also set:

• status = published if publish_flag was publish.
• status = generated if publish_flag was draft.

This keeps my spreadsheet the single source of truth. I can filter ideas, generated drafts, and published content without logging into Ghost.

Module 11: Ghost “Update a post” (branch 2)

On the update branch, I use Ghost > Update a post with the stored ghost_post_id.

I do not blindly overwrite everything. Here is my mapping logic:

• Always update HTML from generated_html.
• Update title and slug only if the sheet values changed.
• Update meta fields if they exist in Sheets. Otherwise keep Ghost values.
• Tags are rebuilt from the tags column every time.

In Make that means I use if expressions in the field mapping. For example:

if(
  empty(sheet_meta_title);
  ghost.meta_title;
  sheet_meta_title
)

I apply a similar pattern for slug and description.

Module 12: Error handling and logging

I do not like silent failures.

So I added a simple error path using Make’s built-in error handlers:

• If Ghost or OpenAI throws an error, I catch it in a separate route.
• Then I write the error message into a errors column in Sheets.
• I also ping myself with a Gmail > Send an email module when something breaks.

Nothing fancy. Enough to see when the pipeline has issues without watching Make all day.

Why I structured it this way

I tried a few alternative versions before landing on this flow.

What I did not like:

• Single gigantic OpenAI prompt that tried to output HTML, meta, title variants, tag suggestions, everything. It was brittle.
• Direct Sheets to Ghost without writing generated content back first. Harder to see what the model produced.
• No publish_flag, so everything went straight to draft in Ghost. That got noisy fast.

What works better for me now:

• Sheets is the control tower. All fields visible. Easy to override.
• Make is the transport layer. No business logic hidden in Ghost.
• OpenAI is a dumb transformer that takes structured inputs and outputs structured HTML and metadata.

The end result is that I spend time on outlines and ideas, not formatting posts or fighting CMS UI.

How this feels in daily use

Here is my actual workflow on a random Tuesday.

• I open the Posts sheet and dump three new ideas as rows with rough titles and briefs.
• I set status = ready and leave publish_flag empty.
• Make picks them up, runs OpenAI, writes back generated HTML and meta, sets status = generated.
• I skim the HTML in Sheets. If a post feels off, I tweak the brief or title, flip status back to ready and let it regenerate.
• Once I like a post, I set publish_flag = draft or publish.
• Next run, Make pushes it into Ghost accordingly.

I still edit inside Ghost sometimes. Especially for code-heavy posts or things where I want to insert images manually.

But 80 percent of the grunt work is automated. Which is the point.

If you want to copy this

If you are already using Make, you can rebuild this in an afternoon.

The three non-negotiables in my experience:

• Use Sheets as a real schema, not a random dumping ground.
• Keep OpenAI prompts tight and specific. One job per call.
• Always round trip data back into Sheets so you can see what the system did.

From there you can layer on extras. Social post generation, image generation, cross-posting to other platforms. I keep those in separate scenarios so this core pipeline stays boring and reliable.

That is the full blueprint I run right now. It will probably change again in a month. But the core idea stays the same. Treat your content as structured data, not as a CMS typing session.

I Built a “Production-Ready” AI Agent Framework. It Was a Lie. So I Fixed It.

A story about AI-generated repos, fake READMEs, and what I did about it.

Two weeks ago, I built an automation pipeline that generates open-source projects on GitHub. The idea: market-research trending tech, scaffold a repo, fill it with code, add docs, and push — fully automated. 14 agents working together. 65 seconds end-to-end. I was proud of it.

Then I actually looked at the generated code.

The Ugly Truth

The pipeline had generated three repos:

• ai-agent-starter: “Production-ready AI agent framework with multi-provider support”
• dev-cli-kit: “Modern CLI toolkit with scaffolding, code generation, and git automation”
• nextjs-saas-starter: “Next.js SaaS starter with auth, payments, and AI integration”

Sounds great, right? Here’s what was actually inside:

The nextjs-saas-starter didn’t even have a src/ directory. Just a package.json, a tsconfig.json, and a README claiming it had “authentication, Stripe payments, and an AI chat interface.” None of those existed. Not even a single component.

The READMEs were AI-generated marketing fluff. Every claim was false. And somehow, each one had donation links (PayPal, Buy Me a Coffee, GitHub Sponsors) — asking for money before delivering a single working line of code.

I had built a lying machine.

What I Did

Instead of deleting the repos (GitHub URLs and star history have value), I decided to make every claim true.

I rewrote all three from scratch, and built a fourth:

1. ai-agent-starter (v0.2.0)

What it claimed → What it now is:

• “Multi-provider support (OpenAI, Anthropic, Ollama)” → Actually implemented all three, with streaming
• “Built-in tool execution engine” → Real function calling via OpenAI/Anthropic native tool APIs, not regex string matching
• “Conversation memory” → Token-aware memory manager with auto-pruning
• “CLI and programmatic API” → npx ai-agent-starter chat, npx ai-agent-starter run "prompt", and importable package

650+ lines of TypeScript, 24 tests, zero build errors.

2. dev-cli-kit (v0.2.0)

The old version’s only source file was cli.ts.hbs — a Handlebars template with // TODO: Implement init logic as its core functionality.

Now: real project scaffolding from 3 built-in templates (Node/TS, React/Vite, CLI tool), code generation (component/hook/util/api), and git workflow helpers. 480+ lines, 8 tests.

3. nextjs-saas-starter (v0.2.0)

From zero lines to a complete Next.js 14 app: landing page (hero, features grid, pricing), dashboard with sidebar + stats, login/register pages, billing page, settings page, API route, Tailwind CSS with dark mode. 520+ lines across 14 files.

4. ai-chat-saas (NEW)

Built on top of the first three — a complete AI chat application. Multi-provider streaming chat with server-side API key protection. 763 lines. Ready to deploy on Vercel in 60 seconds.

What I Learned

1. AI-generated code isn’t the problem — unverified AI-generated code is. My pipeline agents were generating template stubs and calling them “production-ready.” The fix was embedding real, tested code as the generation template.

2. READMEs should describe what EXISTS, not what you WISH existed. Every line in the new READMEs corresponds to actual code you can run.

3. Donation links on empty repos are a red flag. If a project has zero working code and asks for money, it damages trust in the entire open-source ecosystem. I removed all donation links and added them back only where appropriate.

4. “Production-ready” means something. It means tests pass, builds succeed, and someone can clone your repo, run npm install && npm run dev, and see a working product. Not a TODO comment.

What’s Next

The pipeline is fixed. The code agents now generate real, working code instead of stubs. Cron runs daily at 16:00 Beijing time.

I’m also launching a paid template — ai-chat-saas — on Gumroad for $19. It’s the chat application with all three providers, streaming, dark mode, and server-side API protection. Clone, set your API keys, deploy.

The moral: if you’re using AI to generate code, verify it. Actually run npm install. Actually run npm test. Actually try to use it. Otherwise you’re just building a very fast bullshit machine.

All repos: github.com/GrahamduesCN