Author: Tuan Nguyen

Jules is Google’s asynchronous AI coding agent that integrates directly with your GitHub repositories to perform tasks like fixing bugs, writing tests, building new features, and bumping dependency versions.

Getting Started:

1. Connect GitHub: Visit jules.google, select your repository and branch
   
   
2. Assign Tasks: Write a detailed prompt for Jules, or add the “jules” label to a GitHub issue
   
   
3. Jules Works: Jules fetches your repository, clones it to a Cloud VM, and develops a plan using the latest Gemini 2.5 Pro model Jules – An Asynchronous Coding Agent
   
   
4. Review & Approve: Jules provides a diff of the changes for you to browse and approve
   
5. Create PR: Once approved, Jules creates a pull request for you to merge and publish on GitHub
   

Why Use Markdown?

1. Better AI Processing

• Semantic understanding: AI models process continuous text more effectively than fragmented cell data
• Context preservation: Paragraph-based content maintains relationships between information
• Effective retrieval: Vector embeddings capture meaning better from natural language text
• Natural chunking: Content splits logically by sections, preserving context in each chunk

2. Cost Efficiency

• Smaller storage: Plain text (5-10KB) vs Excel with formatting overhead (50-100KB+)
• Lower token usage: Markdown structure is simpler, reducing embedding and processing tokens
• Faster processing: Text parsing is significantly faster than Excel binary format

3. Operational Benefits

• Version control friendly: Git tracks line-by-line changes effectively
• Universal editing: Any text editor works, no proprietary software needed
• Better collaboration: Merge conflicts are easier to resolve in plain text
• Automation ready: Easily integrated into CI/CD and documentation workflows

4. When to Use Excel?

XLSX may be suitable when:

• You need structured tabular data with calculations/formulas
• Data is primarily numerical with specific formatting requirements
• Direct import/export with database systems or business intelligence tools
• Non-technical users need to edit data in familiar spreadsheet interface

However, for knowledge bases consumed by AI, converting to Markdown yields better results even for tabular data.

Demo: Converting XLSX to MD

You can create a custom plugin tool on Dify to convert Excel files to Markdown. Here’s how I built mine:

Implementation Steps

1. Accept XLSX file input
   • Require Xlsx File parameter and wrap its blob in a BytesIO stream
2. Configure column selection
   • Extract Selected Columns parameter (accepts list/JSON string/comma-separated string)
   • Ensure it is non-empty
3. Set delimiter
   • Resolve Delimiter parameter for separating entries
4. Parse Excel file
   • Read the first worksheet into a DataFrame using pandas
   • Verify all requested columns exist in the DataFrame header
   • Subset DataFrame to selected columns only
   • Normalize NaN values to None
5. Transform to structured data
   • Convert each row into a dictionary keyed by selected column names
   • If no rows remain, emit message indicating no data and stop
6. Generate Markdown
   • Build content by writing column: value lines per row
   • Append delimiter between entries
   • Join all blocks into final Markdown
7. Output file
   • Derive filename from uploaded file metadata
   • Emit blob message with Markdown bytes and metadata

Sample

Input

 

Output

Have you ever asked someone to help you with a project, only to get back something that looks right but isn’t quite what you wanted? That’s exactly what happens when we work with AI coding assistants today. We describe what we want, get code back, and often find ourselves saying “Well, it’s close, but…”

GitHub just released a free tool called Spec Kit that solves this problem by teaching us a better way to communicate with AI assistants. Think of it as a structured conversation method that helps both you and the AI stay on the same page.

The Problem: Why “Just Tell the AI What You Want” Doesn’t Work

Imagine you’re renovating your kitchen and you tell the contractor: “I want it to look modern and functional.” Without more details, they’ll make their best guess based on what they think “modern” and “functional” mean. The result might be beautiful, but probably won’t match your vision.

The same thing happens with AI coding assistants. When we give vague instructions like “build me a photo sharing app,” the AI has to guess at hundreds of details:

• How should users organize their photos?
• Can they share albums with friends?
• Should it work on phones and computers?
• How do they sign in?

Some guesses will be right, some won’t, and you often won’t discover the problems until much later in the process.

The Solution: Spec-Driven Development

Spec-Driven Development is like having a detailed conversation before starting any work. Instead of jumping straight into building, you:

1. Clearly describe what you want (the “what” and “why”)
2. Plan how to build it (the technical approach)
3. Break it into small steps (manageable tasks)
4. Build it step by step (focused implementation)

The magic happens because each step builds on the previous one, creating a clear roadmap that both you and the AI can follow.

How Spec Kit Makes This Easy

Spec Kit provides a simple toolkit with four phases that anyone can learn:

Phase 1: Specify – “What do you want to build?”

You describe your vision in plain language, focusing on:

• Who will use it? (your target users)
• What problem does it solve? (the main purpose)
• How will people use it? (the user experience)
• What does success look like? (your goals)

Example: Instead of “build a task manager,” you’d say:

“Build a team productivity app where project managers can assign tasks to engineers, team members can move tasks between ‘To Do,’ ‘In Progress,’ and ‘Done’ columns, and everyone can leave comments on tasks. It should be easy to see at a glance which tasks are yours versus others.”

Phase 2: Plan – “How should we build it?”

Now you get technical (but still in everyday terms):

• What technology should we use? (website, mobile app, etc.)
• What are the constraints? (budget, timeline, compatibility needs)
• What are the rules? (security requirements, company standards)

Example:

“Build this as a simple web application that works in any browser. Store data locally on the user’s computer – no cloud storage needed. Keep it simple with minimal external dependencies.”

Phase 3: Tasks – “What are the specific steps?”

The AI breaks your big vision into small, manageable pieces:

• Create user login system
• Build the task board layout
• Add drag-and-drop functionality
• Implement commenting system

Each task is something that can be built and tested independently.

Phase 4: Implement – “Let’s build it!”

Your AI assistant tackles each task one by one, and you review focused changes instead of overwhelming code dumps.

Why This Approach Works Better

Traditional approach: “Build me a photo sharing app” → AI makes 1000 assumptions → You get something that’s 70% right

Spec-driven approach: Clear specification → Detailed plan → Small tasks → AI builds exactly what you described

The key insight is that AI assistants are incredibly good at following detailed instructions, but terrible at reading your mind. By being explicit upfront, you get much better results.

Getting Started with Spec Kit

Spec Kit works with popular AI coding assistants like:

• GitHub Copilot
• Claude Code
• Gemini CLI

Installing and Using Spec Kit

1. Install Specify

uv tool install specify-cli –from git+https://github.com/github/spec-kit.git
specify init reading-assistant

2. Establish project principles

/constitution Create principles focused on code quality, testing standards, user experience consistency, and performance requirements

3. Create the spec

/specify
GOAL
– Input: URL (or pasted text)
– Process: Fetch article → summarize (150–250 words) → generate 3–5 practice questions
– Output: Markdown with Summary, Questions, Source
– Constraint: Minimal Python CLI

4. Create a technical implementation plan

/plan
ARCHITECTURE
– Python CLI with argparse
– Modules:
• fetcher.py: download HTML
• extractor.py: parse text with BeautifulSoup
• llm.py: call OpenAI (gpt-4o-mini)
• markdown.py: render Markdown
– Flow: URL/text → fetch & extract → LLM → Markdown → stdout

DEPENDENCIES
– requests, beautifulsoup4, python-dotenv

OUTPUT FORMAT
# Summary
<summary>

# Questions
1. …
2. …

# Source
<url or ‘pasted text’>

5. Break down into tasks

/tasks
– [ ] Setup project skeleton + requirements
– [ ] Implement fetcher (requests)
– [ ] Implement extractor (BeautifulSoup)
– [ ] Implement LLM client with prompt
– [ ] Implement Markdown renderer
– [ ] Wire CLI (argparse)
– [ ] Smoke test with one URL and one pasted file
– [ ] Add README with quick start

6. Execute implementation

/implement
FILES
1) requirements.txt
requests
beautifulsoup4
python-dotenv

2) app.py
– argparse: –url, –text
– orchestrate modules and print Markdown

3) fetcher.py
– fetch_url(url) with timeout, retry

4) extractor.py
– extract_text(html) → title + paragraphs

5) llm.py
– summarize_and_ask(text) → {“summary”: str, “questions”: [str]}
– uses OPENAI_API_KEY; friendly error if missing

6) markdown.py
– render(result, source) → Markdown string

7) README.md
– Quick start instructions
– Example commands

 

Result

 

References:

https://github.com/github/spec-kit

https://github.blog/ai-and-ml/generative-ai/spec-driven-development-with-ai-get-started-with-a-new-open-source-toolkit/

Introduction

AIPM (AI‑powered Project Management) v0 is an innovative framework designed by Miyatti that uses PMBOK, Lean UX, and Agile methodologies—streamlines the project lifecycle through AI assistance and structured documentation workflows.

Core Components

1. Three-tier document structure:
   Flow: a draft workspace with date‑organized notes.
   Stock: approved, formal deliverables stored by phase.
   Archive: immutable records of completed projects.
2. Workflow engine: LLM-assisted “Ask → Draft → Review → Sync” process, managed by a robust rules engine built on .mdc files.
3.  Hybrid methodology:
   PMBOK for structure (“What”).
   Lean UX for discovery (“Why”).
   Agile for execution (“How”).

Strengths

• Efficient documentation: Only drafts that pass review move to Stock, reducing clutter and focusing on essential deliverables.
• Methodological rigor: Combines PMBOK’s structure, Lean UX’s problem framing, and Agile’s adaptability in a unified workflow.
• LLM-powered automation: Accelerates document creation with tailored prompts and templates, reducing repetitive admin tasks.
• Customizable rules: Built around easy-to-edit .mdc files (e.g., 00_master_rules, flow_to_stock_rules), making it extensible and flexible.
• Seamless dev integration: Includes support for development workflows (e.g., environment setup, story planning), ensuring tech tasks are synced with PM processes.

Weaknesses

• Steep learning curve: Requires familiarity with .mdc syntax and rule logic to fully harness system capabilities.
• Tool & language lock-in: Depends on the Cursor editor and Japanese trigger phrases.
• Version Control Complexity: Managing collaborative work across the Flow/Stock/Archived structure may become complex in larger teams without proper version control strategies.

How to use

A. System Requirements

• Cursor editor for LLM prompts.
• Git for cloning the repo.
• Bash or compatible shell.

B. Quick Setup (via Cursor)

• Open Cursor and select New Window.
• Enter the repository URL: https://github.com/miyatti777/aipm_v0.
• In the Chat panel, type: “Please perform initial setup / 初期設定お願いします” — Cursor will automate folder structure and rule setup.

C. Manual Setup

• Clone the Repository.
  git clone https://github.com/miyatti777/aipm_v0.git
  cd aipm_v0
• Run Setup Script.
  ./setup_workspace_simple.sh setup_config.sh
  
• Verify the directory structure.
  

D. Configuration Options

• Edit setup_config.sh (AUTO_APPROVE, AUTO_CLONE, RULE_REPOS, PROGRAM_REPOS) to customize behaviors, templates.
• Set user rules from the Cursor settings (you can change the original rules from Japanese to English).
  #========================================================
  # 0. Base Policy
  #========================================================
  ! Always respond in English
  – Check if any rules are attached. If so, be sure to load them. Mark with ✅ once loaded.
  – Deliverables should be created as files using `edit_file` where possible (split into smaller parts).
  – Tasks such as MCP or file viewing should be executed autonomously if possible.
  – When receiving a task request, identify missing information, plan by yourself, and proceed to the goal.#========================================================
  # 0. Safe Execution of Shell Commands
  #========================================================
  ! Important: Prohibited and recommended practices when executing commands
  – Absolutely do not use subshell functions (`$(command)` format).
  – Backticks (“command“) are also prohibited.
  – Complex commands using pipes (`|`) or redirects (`>`) must be broken into simple, individual commands.
  – When date information is needed:
  1. First, run a standalone `date` command and get the terminal output.
  2. Use the resulting date string explicitly in the next command.
  3. Example: Run `date +%Y-%m-%d` → output `2024-05-12` → use this string directly.! Command Execution Example
  – Not Allowed: `mkdir -p Flow/$(date +%Y%m)/$(date +%Y-%m-%d)`
  – Allowed: [Break into the following two steps]
  1. `date +%Y%m`
  2. `date +%Y-%m-%d`
  3. `mkdir -p Flow/{output1}/{output2}`#========================================================
  # 1. Mandatory Rule File References (pre-load)
  #========================================================
  # * Prioritize loading `pmbok_paths_*.mdc` first. All subsequent paths
  # should be referenced using {{dirs.*}} / {{patterns.*}} variables.required_rule_files:
  – /Users/<YOUR_USER>/{{PROJECT_ROOT}}/.cursor/rules/basic/pmbok_paths.mdc
  – /Users/<YOUR_USER>/{{PROJECT_ROOT}}/.cursor/rules/basic/00_master_rules.mdc

E. Usage

Project Initialization

• Start by typing: “I want to make curry. Please start a project.” (Japanese: カレー作りたい プロジェクト開始して).
  
  
• After that, you can continue with commands like:
  “I want to create a project charter.”
  “Define the product.”
  “I want to do stakeholder analysis.”
  
•  For each step, the AI will ask for your confirmation. If everything looks good, you can reply with “Confirm and reflect” to proceed.

You can continue with other phases, as shown in this example: [Usage by phase]

 

References

https://github.com/miyatti777/aipm_v0

https://deepwiki.com/miyatti777/aipm_v0