『KNN_yaml_md』Create AI-friendly and human-friendly .md files for free! A web app that generates Markdown with Front Matter from local files.

This is KNN Paul Kanda.

While asking AI about the differences between .yaml and .md, I came to understand how to create an AI-readable file format by integrating them into a single .md file.

With that in mind, I wanted to develop a web app that could instantly generate Markdown with Front Matter just by entering text or specifying a URL on the web, so I had an AI help me think of the prompts.

Anyway, I built it and published it!

Web importing isn't very practical yet, so I'll improve it. The design needs work too.

Why did I develop it?

It's convenient to have files that are amphibians—both AI-friendly YAML and human-friendly MD!

This is a web app that generates Markdown with Front Matter from URLs, PDFs, and local files.

Extract body text, summaries, and metadata from article URLs, PDFs, HTML/Markdown/text files, or directly pasted text to generate Markdown files with YAML Front Matter.All processing is completed within your browser.

Main Features

• URL Input — Extract title, body, author, publication date, OGP information, etc., from article URLs (using Mozilla Readability)

• PDF Reading — In-browser text extraction using PDF.js (pdfjs-dist). Retrieves metadata and page counts, and corrects line break issues and repeating headers/footers

• Local File Reading — Supports .html / .htm / .txt / .md / .markdown (up to 20MB). Detects existing Markdown with Front Matter and allows you to choose to 'Keep / Update / Merge / Regenerate'

• Direct Text Input — Paste body text and input arbitrary metadata

• Rule-based Summarization — Generates short summaries (100–160 characters) and detailed summaries (300–500 characters) using sentence importance scoring without external AI

• Tag/Keyword Extraction — Extracts candidates such as katakana words, kanji compound words, and English proper nouns using lightweight rule-based processing. Editable in chip format

• YAML Front Matter Generation — Uses js-yaml to output valid YAML that won't break even with titles containing colons or quotes

• Preview and Edit — Three tabs for YAML / Markdown / Rendering preview. Edits can be saved directly

• Save and Copy — Save as .md file (Blob URL, supports Japanese filenames), copy entire content / YAML only / body only

Privacy Policy

KNN_yaml_md does not collect or store input URLs, article text, PDFs, local files, or file names.

• PDFs and local files are not uploaded to a server; all processing is performed within your browser.

• No external AI APIs, proprietary servers, databases, cloud storage, access analytics, or ad tracking are used.

• Article data is not saved to localStorage, IndexedDB, or Cookies. Input is discarded when the page is closed.

• No libraries are loaded from external CDNs during execution (the PDF.js worker is bundled in the build).

• No external web fonts are used (displayed using system fonts).

Only when using URL input, the browser accesses the website of the entered URL directly. It does not pass through the KNN_yaml_md server or any third-party APIs.

Limitations

• CORS Restrictions — Because processing occurs only within the browser, articles may not be retrievable depending on the target site's CORS settings (best-effort basis). If retrieval fails, please paste the body text into the 'Text' tab, or save it as HTML or PDF and load it as a local file. We do not use CORS proxies or external APIs to bypass this.

• Image PDFs (No OCR support) — Text cannot be extracted from PDFs scanned as images. The current version does not support OCR.

• Rule-based summarization — Summaries are generated using in-browser text extraction processing without using external AI.

The following is a prompt thought up by the free version of ChatGPT.
It's amazing that it's free, and it was just by giving instructions for the three prompts below.
I can't help but feel that it might be a bit too detailed.

I will hand it over to ClaudeCode.

I just happened to want to save on token consumption for ChatGPT, or rather, ClaudeCode lol

Wow! In no time at all, 32 requirement definition documents were created!

Claude Code Development Instructions
KNN_yaml_md
0. Handling of these instructions
Please treat this entire document as a single development instruction manual.
The goal is to develop a web app, 'KNN_yaml_md', that extracts body text, summaries, and metadata from article URLs, local files, or directly entered text, and generates a Markdown file with YAML Front Matter.
This app does not use external AI APIs, cloud storage, proprietary servers, or databases; in principle, all processing is completed within the user's browser.
Please configure it so that the source code can be published on GitHub and the app can be deployed as a static web app on Vercel.
However, you must absolutely not push to GitHub or deploy to Vercel until you have obtained the user's approval regarding the UI and design.

1. App Name
The official name shall be as follows:
KNN_yaml_md
Please use this name for the on-screen title, HTML title, README, package.json, GitHub repository name candidates, and Vercel project name candidates.
You may use the following as a supplementary display title:
KNN_yaml_md: Generate Markdown with Front Matter from URLs, PDFs, and local files
Do not change, abbreviate, or camel-case the app name without permission.

2. Project Overview
'KNN_yaml_md' is a web app that reads the following input data, extracts the article body, summary, and metadata, and generates a Markdown file with YAML Front Matter.
There are four input methods:
Article URL
PDF file
Local files such as HTML, Markdown, or text
Direct text pasting
Please allow the user to specify the output Markdown filename as they wish.
If no filename is specified, please generate it automatically from the article title.

3. Most Important Principles
You must strictly adhere to the following conditions:
Do not use external AI APIs
Do not use OpenAI API
Do not use Anthropic API
Do not use Gemini API
Do not use external summarization APIs
Do not use a proprietary backend
Do not use Vercel Functions
Do not use Serverless Functions
Do not use Edge Functions
Do not use API Routes
Do not use Server Actions
Do not use databases
Do not use cloud storage
Do not provide user registration features
Do not provide login features
Do not collect email addresses
Do not collect personal information
Do not use Google Analytics
Do not use ad tracking
Do not use external access analysis services
Do not send input data to a server
Do not save URLs, body text, filenames, or file contents
Do not save article data to localStorage
Do not save article data to IndexedDB
Do not save article data to Cookies
Design it so that input data is discarded when the page is closed
Handle input data only in the browser's memory
Minimize external communication
Do not load libraries from external CDNs at runtime
Incorporate libraries as npm packages during the build process
Do not make external web fonts mandatory
Prioritize configurations that do not connect to Google Fonts
Clearly display the following content on the screen:
The entered URL, article body, PDF, local file, and filename are not saved or collected. Files are not uploaded to a server, and all processing is performed within your browser. External AI APIs, databases, cloud storage, access analysis, and ad tracking are not used.

4. Technical Configuration
The basic configuration shall be as follows:
Vite
React
TypeScript
CSS Modules or standard CSS
Build as a static site
Deployable on Vercel
Deployable on GitHub Pages
Node.js used only during development and build
No runtime backend
Candidate dependency packages are as follows:
@mozilla/readability
dompurify
js-yaml
marked
turndown
pdfjs-dist
The following can be used if necessary:
react-dropzone
lucide-react
Keep dependency packages to the absolute minimum.
For each library, please document the following in the README:
Purpose of use
That it is processed within the browser
That it does not send data to external servers
License

5. Screen Layout
Design the screen as a modern web app.
On desktop, it should basically be a two-column layout.
Left Column
Input method selection
URL input
File reading
Text input
Extracted metadata editing
Tag editing
Keyword editing
Output options
Output filename
Right Column
YAML Front Matter preview
Markdown source preview
Markdown rendering preview
Editing of generated results
Copy and save buttons
If the screen width is narrow, switch to a single-column vertical layout.

6. Input Interface
Please allow input methods to be switched via tabs.
The tab names shall be as follows:
URL, PDF, File, Text
Do not integrate PDF into the File tab; display it as an independent tab.
However, the drag-and-drop area may accept all supported files, including PDFs.

7. URL Input Function
Please provide a URL input field and a 'Get Article' button.
For URLs that can be accessed directly from the browser, fetch the HTML and extract the following:
Article title
Body text
Author name
Publication date
Update date
Site name
Meta description
Canonical URL
OGP title
OGP description
OGP site name
Headings
Keyword candidates
Language
Original article URL
Use Mozilla Readability for HTML parsing.
You can use Turndown or similar for converting HTML to Markdown.
Sanitize external HTML using DOMPurify or similar.
CORS Restrictions
Because processing is done only within the browser, you may not be able to fetch articles depending on the CORS settings of the external site.
To bypass CORS restrictions, you must not use the following:
External CORS proxies
Proprietary proxy servers
Vercel Functions
Cloudflare Workers
External scraping services
External article extraction APIs
If fetching fails, display the following guidance:
This site cannot be fetched directly due to browser security restrictions. Please paste the article body into the 'Text' tab, or save the article as HTML or PDF and read it as a local file.
URL fetching should be a best-effort method.
Do not use expressions that might lead users to misunderstand that 'all URLs can be fetched'.

8. PDF Reading Function
Please enable reading PDF files within the browser and extracting text.
In principle, use pdfjs-dist for PDF parsing.
Do not upload PDF files to a server; parse them within the browser using the File API, ArrayBuffer, and PDF.js.
Information to extract from PDF
Extract the following to the extent possible:
PDF filename
PDF metadata title
PDF metadata author
PDF metadata creation date
PDF metadata update date
Page count
Text of each page
- Entire body text
Heading candidates
Title candidates from the first page
Keyword candidates
Language candidates
PDF Text Processing
In PDFs, the order of extracted strings and line breaks can sometimes be broken.
Please implement the following corrections:
Combine unnatural line breaks to the extent possible
Correct line breaks in the middle of words
Clean up consecutive spaces
Exclude lines containing only page numbers
Exclude repeating headers and footers to the extent possible
Exclude excessive repetition of the same string
Option to keep page boundaries as Markdown comments or headings
Correction for unnatural spaces between characters in Japanese PDFs
Correction for hyphenated words in English PDFs
Handling Image-based PDFs
For PDFs scanned as images, body text cannot be extracted with standard PDF.js alone.
Do not make OCR mandatory for the MVP.
If text cannot be extracted, display the following guidance:
Text could not be extracted from this PDF. It may be a PDF scanned as an image. The current version of KNN_yaml_md does not support OCR. Please copy the text and paste it into the 'Text' tab.
Do not use external OCR APIs.
Design it so that in-browser OCR can be considered as a future expansion. However, do not force large libraries like Tesseract.js into the MVP.
PDF Preview
Do not embed the PDF itself into external services.
If necessary, display only the following:
Filename
File size
Page count
Extracted character count
Beginning portion of extracted text
Status of extraction success or failure

9. Local File Reading
Support both drag-and-drop and a file selection button.
On the screen, prioritize the following expression over 'Upload':
Read local file
As a supplement, display the following:
Files are not uploaded to a server. They are processed only within your browser.
Supported Formats
Support the following in the MVP:
.pdf
.html
.htm
.txt
.md
.markdown
Verify not only file extensions but also MIME types to the extent possible.
Display a clear error for unsupported formats.
File Size Limit
Support up to 20MB as an initial value.
Since PDFs can be processing-intensive depending on page count and content, display the following information:
File size
Page count
Processing indicator
Processing completion indicator
Error indicator
Perform asynchronous processing so that the UI does not freeze due to large PDFs.
Use Web Workers if necessary.

10. Direct Text Input
Provide a large text area.
Allow users to paste article or document bodies directly.
Provide the following as optional input items:
Article title
Author name
Publication date
Update date
Original article URL
Site name
Language
Category
For items not entered, estimate them from the body text to the extent possible.

11. Output Filename
Provide an input field where the user can specify the name of the Markdown file.
The label shall be as follows:
Output filename
Example:
softbank-world-2026
Automatically add .md when saving.
softbank-world-2026.md
If the user has already added .md, do not add it twice.
Support Japanese filenames as well.
Replace characters that cannot be used in filenames with safe characters.
Examples of characters to replace:
/ \ : * ? " < > |
If the filename is empty, generate it automatically in the following order of priority:
User-entered title
Extracted article title
PDF title
Original filename
untitled
Allow the filename to be edited before saving.

12. YAML Front Matter
Add YAML Front Matter to the beginning of the generated result in the following format:
--- title: "" author: "" date: "" updated: "" source_url: "" site_name: "" description: "" summary: "" tags: [] keywords: [] language: "ja" content_type: "article" source_type: "" original_filename: "" page_count: 0 word_count: 0 reading_time: 0 created_at: "" ---
For source_type, insert the following according to the input source:
source_type: "url"
source_type: "pdf"
source_type: "html"
source_type: "markdown"
source_type: "text"
Allow the following items to be added if necessary:
category: "" status: "reference" slug: "" headings: [] pdf_metadata: producer: "" creator: "" creation_date: "" modification_date: ""
YAML Generation Rules
Format it so it can be correctly interpreted as YAML
Enclose strings in double quotes if necessary
Properly escape characters within double quotes
Ensure YAML is not broken by strings containing colons
Block format may be used for long text containing line breaks
Tags and keywords should be arrays
Empty arrays should be []
Numbers should be numeric types
Date format should be YYYY-MM-DD in principle
Use ISO 8601 format for created_at
Do not assert unacquired items based on guesses
Allow users to choose between empty strings or omission for items without information

13. Summary Generation
Generate rule-based summaries within the browser without using external AI APIs.
Summarization Method
Extract important sentences by combining the following elements:
Relevance to the title
Sentences at the beginning of the body
Sentences immediately following headings
Frequently occurring words
Proper noun candidates
Sentence length
Sentences containing numbers
Sentences indicating conclusions
Exclude duplicate sentences
Exclude advertisements and navigation
Exclude sentences consisting only of reference links
Exclude PDF headers, footers, and page numbers
Types of Summaries
Generate the following two types:
Short Summary
Approximately 100 to 160 characters.
Detailed Summary
Approximately 300 to 500 characters.
Include the short summary in the Front Matter's summary by default.
Allow the user to choose whether to add the detailed summary to the Markdown body.
Checkbox:
Add a 'Summary' section to the beginning of the body
Display a small note on the screen that it is a rule-based summary.
Summaries are generated by text extraction processing within the browser without using external AI.
Do not use expressions like 'AI-summarized'.

14. Tag and Keyword Extraction
Analyze the following within the browser without using external APIs:
Important words contained in the title
Words contained in headings
Frequently occurring words
English product names
Company name candidates
Person name candidates
Service name candidates
Proper expressions containing numbers
Hashtags
Keywords from PDF metadata
HTML meta keywords
Exclude the following:
Particles
Auxiliary verbs
Words that are too general
Single-character Japanese
Duplicate words
URLs
Unnecessary symbols
Navigation terms
Cookie-related displays
Ad-related words
Display extraction results in a chip format or similar.
Allow the user to perform the following:
Add tag
Delete tag
Edit tag
Add keyword
Delete keyword
Edit keyword
Reorder
Do not make complete Japanese morphological analysis a mandatory requirement for the MVP.
If dependency packages become excessively large, prioritize lightweight rule-based processing.

15. Markdown Body Generation
The basic structure of the generated Markdown shall be as follows:
--- YAML Front Matter --- # Article Title ## Summary Summary text ## Body Article body ## Source - Original article URL: - Site name: - Author: - Publication date: - Original file:
Allow each item to be toggled on/off.
Output Options
Add H1 title
Add summary section
Add body section heading
Add source section
Maintain original article heading structure
Maintain PDF page breaks
Maintain HTML links
Maintain image URLs
Remove HTML tags
Exclude empty Front Matter items
Maintain original Markdown Front Matter
Overwrite existing Front Matter with new content
Merge with existing Front Matter
When reading a Markdown file, detect existing Front Matter.
If existing Front Matter is present, display the following options:
Maintain existing Front Matter, Update existing Front Matter, Merge with existing Front Matter, Delete existing Front Matter and regenerate

16. Preview and Editing
In the right-side preview area, allow switching between the following tabs:
YAML, Markdown, Preview
YAML Tab
Display Front Matter only
Editable
Display YAML syntax errors
Copy YAML only
Markdown Tab
Display entire Markdown
Editable
Line number display is optional
Copy entire content
Preview Tab
Display Markdown safely as HTML
Sanitize with DOMPurify or similar
Do not execute external scripts
Do not display iframes
Disable javascript: links
Allow the edited content to be saved as-is.

17. Output Function
Provide the following buttons:
Generate Markdown
Regenerate Markdown
Copy to clipboard
Save .md file
Copy YAML only
Copy body only
Clear input
Use Blob URL for file saving.
Complete the saving process within the browser.
Do not implement features for saving to external storage.

18. Design Requirements
Design the interface with a modern pink-based theme.
It should not be a simple all-pink design, but a combination of white, light gray, and pale pink, suitable for both readability and professional use.
Design Concept
Modern Pink Gradient Soft Motion Privacy First Editorial Tool
Color Direction
Candidate colors:
Background: #FFF8FC #FFF4FA #FAFAFC Main Pink: #EC4899 #F472B6 #DB2777 Pale Pink: #FCE7F3 #FDF2F8 #FBCFE8 Text: #18181B #3F3F46 #71717A Border: #F5D0E3 #E4E4E7 Success: #16A34A Warning: #D97706 Error: #DC2626
Colors are tentative.
Before publishing on GitHub, present the actual screen to the user for consultation.
Pink 'Fluctuation'
Add a 'fluctuation' effect to the background where a pale pink gradient moves slowly.
Implementation candidates:
Multiple radial-gradients
CSS animation
blurred gradient blob
background-position animation
Movement of pale light via pseudo-elements
The fluctuation must adhere to the following conditions:
Not too flashy
Does not impair the readability of input text
Does not move fast
Does not constantly distract the eye
Keep CPU load low
Keep GPU load low
Does not become heavy on mobile devices
Does not impair scrolling performance
Does not cause flickering
Animation time should be a gentle cycle of approximately 15 to 30 seconds.
Accessibility
If 'prefers-reduced-motion: reduce' is set in the OS or browser, stop the background fluctuation.
@media (prefers-reduced-motion: reduce) { /* stop animation */ }
Consider a setting where the user can manually stop the background animation.
Display name example:
Background fluctuation On / Off
Even if saving settings, do not save article body, URL, filename, etc.
If saving only UI settings to localStorage, clearly state this to the user.
A design that does not save anything is also acceptable.
UI Elements
Rounded cards
Subtle shadows
Translucent panels
Pale borders
Larger input fields
Clear tabs
Pink-based primary buttons
Small notification upon copy completion
Progress display during processing
Page progress during PDF parsing
Visual feedback when dragging files
Keyboard operable
Sufficient contrast
Avoid excessive glassmorphism.
As a long-text editing tool, prioritize text readability above all else.

19. Header
Display the following in the header:
KNN_yaml_md
Sub-copy:
Generate Markdown with Front Matter from URLs, PDFs, and local files
Display a small privacy badge on the right or bottom.
Browser Only No Upload No AI API
You may also include the Japanese translation.
In-browser processing, no external transmission, no AI API

20. Privacy Display
Ensure the privacy explanation is always visible within the screen.
Display it in at least the following three locations:
Privacy badge near the header
Near the file selection area
Footer
Detailed Display Text
KNN_yaml_md does not collect or save entered URLs, article bodies, PDFs, local files, or filenames. PDFs and local files are not uploaded to a server, and all processing is performed within your browser. External AI APIs, databases, cloud storage, access analysis, and ad tracking are not used. Input content is discarded when the page is closed.
Include similar content in the README.

21. Security Requirements
Since you are processing external HTML and Markdown, be sure to implement XSS countermeasures.
Do not insert external HTML directly into the DOM
Remove script tags
Remove style tags if necessary
Remove iframes
Remove object tags
Remove embed tags
Remove event handler attributes
Remove javascript: URLs
Restrict data: URLs
Disable scripts within SVG
Sanitize Markdown preview
Verify URL schemes
Verify file formats
Verify file sizes
Load PDF.js worker safely
Do not fetch worker from CDN
Include worker from npm package in local build
Configure it so that Content Security Policy can be set
Set security headers in vercel.json or HTML meta tags if necessary.
Candidates:
Content-Security-Policy
X-Content-Type-Options
Referrer-Policy
Permissions-Policy
X-Frame-Options or CSP frame-ancestors
However, ensure it works correctly with static hosting.

22. Verification of External Communication
After development, check the Network tab in the browser's DevTools.
Verify the following:
No external transmission occurs when reading PDFs
No external transmission occurs when reading local files
No external transmission occurs when pasting text
No external transmission occurs when generating Markdown
No external transmission occurs when copying
No external transmission occurs when saving
No external font communication occurs
No external analysis communication occurs
No external AI API communication occurs
PDF.js worker is not fetched from an external CDN
In the URL input function, communication occurs to fetch the URL specified by the user.
Clearly state this point on the screen and in the README.
Only when using URL input, the browser accesses the website of the entered URL directly. It does not go through the KNN_yaml_md server or third-party APIs.

23. Error Handling
Handle the following situations:
Invalid URL format
Non-HTTP URLs
URL fetch failure
CORS restrictions
Network error
Article body cannot be detected
PDF is corrupted
PDF is encrypted
PDF is password-protected
Text cannot be extracted from PDF
PDF is image-only
PDF has a very large number of pages
Unsupported file format
File size too large
File character encoding cannot be recognized
YAML generation error
Markdown conversion error
Copy to clipboard failure
File save failure
Browser does not support required APIs
For errors, display the following two points:
Cause of the occurrence
Next action for the user
Do not end with just 'An error occurred'.

24. Processing Indicator
Processing PDFs or large files may take time.
Display the following:
Reading file
Parsing PDF
Current page
Total pages
Formatting text
Extracting metadata
Generating Markdown
Complete
Abort
If possible, allow PDF parsing to be aborted.
Prioritize a design where the entire screen does not become unresponsive during processing.

25. README.md
Include the following in the GitHub README:
App name 'KNN_yaml_md'
App overview
Main features
URL input function
PDF support
HTML, Markdown, and text support
YAML Front Matter generation
Markdown saving
Privacy policy
That data is not saved
That files are not sent to a server
That external AI APIs are not used
That proprietary servers are not used
That direct communication to the target site occurs only during URL input
That some URLs cannot be fetched due to CORS restrictions
That image-based PDFs are not supported for OCR
Supported browsers
How to run locally
Installation method
Development commands
Build method
How to publish to Vercel
How to publish to GitHub Pages
Libraries used
Security precautions
License
Contribution method
Unless otherwise specified, the license shall be the MIT License.

26. Assumed Directory Structure
Please refer to the following.


You may improve this structure as necessary.
However, do not consolidate features into one giant component.

27. Testing
Perform at least the following tests:
URL
URLs that can be fetched normally
URLs that fail due to CORS
Pages without article body
Invalid URLs
Non-HTTP URLs
PDF
Japanese text PDF
English text PDF
Multi-page PDF
PDF with metadata
PDF without metadata
Image-only PDF
Corrupted PDF
Password-protected PDF
Large-capacity PDF
File
HTML
TXT
Markdown
Markdown with Front Matter
Text with different character encodings
Unsupported files
Oversized files
Output
YAML syntax is correct
Japanese title
Title containing colons
Title containing double quotes
Multi-line summary
Empty tags
Japanese filename
Filename containing forbidden characters
Prevention of double .md extension
Copy
File save
Privacy
Body text does not remain in localStorage
Body text does not remain in IndexedDB
Body text does not remain in Cookies
Body text does not remain after reload
PDF content is not sent externally
No external AI API communication
No access analysis communication
Design
Desktop
Tablet
Mobile
Dark mode is optional for initial MVP
prefers-reduced-motion
Keyboard operation
Contrast
Long text display
Long filenames
Long tags

28. Development Phases
Strictly adhere to the following order:
Phase 1: Requirement Organization
Before writing code, present the following:
Understanding of requirements
Technical constraints
CORS restrictions
PDF support policy
That image-based PDFs are not supported for OCR
Technical configuration
Directory structure
Security policy
Privacy policy
Development procedure
Phase 2: Local Implementation
Implement in a local environment.
Do not push to GitHub at this point.
Do not deploy to Vercel.
Phase 3: Local Operation Verification
Verify the following:
URL input
PDF reading
HTML reading
Markdown reading
TXT reading
Text input
Metadata extraction
Summary generation
Tag generation
YAML generation
Markdown generation
Copy
.md saving
Data is not sent externally
Input content does not remain after reload
Responsive display
Error handling
reduced-motion support
Phase 4: UI/Design Consultation
Once the local MVP is working, be sure to stop work.
You must not push to GitHub at this point.
You must not deploy to Vercel.
Present the following to the user:
Screenshots of the entire screen
Desktop display
Mobile display
Header
URL tab
PDF tab
File tab
Text tab
YAML preview
Markdown preview
Pink color scheme
Background fluctuation
Button colors
Fonts
Card rounding
Shadow intensity
Privacy display position
Motion speed
Display during reduced-motion
Then, consult with the user regarding the following:
Pink intensity
Gradient direction
Fluctuation intensity
Fluctuation speed
Background brightness
Button shapes
Card shapes
Fonts
Margins
Privacy display
Presence of logo
Necessity of dark mode
Phase 5: Design Correction
Reflect the user's instructions.
Phase 6: Final Pre-publication Check
Present the following:
Final screen
Changes made
List of files to be published
package.json
Major dependency packages
README overview
Privacy policy
Security check results
Network communication check results
Git diff
Build results
Test results
Phase 7: GitHub Publication
Execute only when the user explicitly instructs one of the following:
Publish to GitHub
Push
Create GitHub repository
Until then, do not publish to GitHub.
Phase 8: Vercel Publication
Execute only when the user explicitly instructs as follows:
Publish to Vercel
Deploy to Vercel
Treat approval for GitHub publication and approval for Vercel publication separately.
Do not judge that Vercel publication is automatically approved just because GitHub publication is approved.

29. Prohibited Git Operations
Do not execute the following without the user's explicit approval:
git push, Create GitHub repository, GitHub Pages publication, Create Pull Request, Create Release, Create Git tag, Vercel deployment, npm publication, Create public URL
Also, explain the execution content for the following operations locally:
git init, git add, git commit, Create branch
Even when performing local commits, clearly distinguish them from pushing to GitHub.

30. Claude Code's Initial Response

Immediately after receiving these instructions, do not perform GitHub or Vercel publication.
In the first response, present the following:
Understanding of 'KNN_yaml_md' requirements
Explanation of local-complete design
CORS restrictions during URL fetching
PDF parsing policy using PDF.js
That image-based PDFs are not supported for OCR
That summarization is rule-based, not external AI

Technical configurationAssumed directory structureSecurity measures
Privacy measures
Implementation policy for pink fluctuation design
Development phases
That you will stop for UI consultation before GitHub publication
That Vercel publication requires separate approval
After the initial response, start local implementation.
Do not ask a large number of detailed design questions at the beginning.
First, implement the local MVP with a tentative modern pink design, and present screenshots during the UI/design consultation phase.

31. Completion Conditions

The local MVP is considered complete when all of the following are met:
App name is 'KNN_yaml_md'
Supports URL input
Supports PDF reading
Supports HTML reading
Supports Markdown reading
Supports TXT reading
Supports direct text input

PDF processing is completed within the browserFiles are not sent to a serverCan extract body text from text-based PDFs
Appropriate guidance is displayed for image-based PDFs
Can extract article body
Can extract metadata
Can generate rule-based summaries
Can generate tags and keywords
Can generate YAML Front Matter
Can generate Markdown body
User can specify output filename
Can use Japanese filenames
Can edit entire Markdown
Can edit YAML
Has Markdown preview
Can save as .md file
Can copy to clipboard
Does not use external AI APIs
Does not use proprietary servers
Does not use databases
Does not use cloud storage
Does not use access analysis
Does not save input data
Modern UI based on pink
Has gentle pink fluctuation in the background
Supports reduced-motion
Supports responsive design
Can be built as a static site on Vercel
Can be published on GitHub Pages
Privacy policy is clearly stated in the README
Not published to GitHub before UI/design approval
Not published to Vercel before user approval

32. Final Prohibitions

Before obtaining the user's explicit approval regarding UI and design, you must not execute the following:
git push, Create GitHub repository, GitHub Pages publication, Vercel deployment, Create public URL
Stop once local implementation and local preview are complete.
Present screenshots and design information, and wait for the user's judgment.
Even after the user approves the design, execute GitHub publication and Vercel publication only after receiving separate explicit instructions for each.